Is list-initialization an implicit conversion?
<pre><code>#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;typeinfo&gt;
#include &lt;typeindex&gt;
#include &lt;map&gt;
#include &lt;vector&gt;

class Base{
public:
    virtual ~Base() {}

};

class Derived: public Base { };

int main(){

    int arr[10];
    Derived d;
    Base *p = &amp;d;

    std::map&lt;std::type_index, std::string&gt; proper_name = {
        {typeid(int), "int"}, {typeid(double), "double"}, {typeid(float), "float"}, {typeid(char), "char"},
        {typeid(Base), "Base"}, {typeid(Derived), "Derived"}, {typeid(std::string), "String"},
        {typeid(int[10]), "Ten int Array"}, {typeid(p), "Base Pointer"}};

}
</code></pre>

<p>I'm trying to make sense of the implicit conversions that occur in this list-initialization. From <code>13.3.1.7</code> of N3337:</p>

<blockquote>
  <p>When objects of non-aggregate class type T are list-initialized (8.5.4), overload resolution selects the constructor in two phases: </p>
  
  <ol>
  <li><p>Initially, the candidate functions are the initializer-list constructors (8.5.4) of the class T and the argument list consists of the initializer list as a single argument.</p></li>
  <li><p>If no viable initializer-list constructor is found, overload resolution is performed again, where the candidate functions are all the constructors of the class T and the argument list consists of the elements of the initializer list.</p></li>
  </ol>
</blockquote>

<p><code>8.5.4</code>:</p>

<blockquote>
  <p>A constructor is an initializer-list constructor if its first parameter is of type <code>std::initializer_list&lt;E&gt;</code> or reference to possibly cv-qualified <code>std::initializer_list&lt;E&gt;</code> for some type <code>E</code>, and either there are no other parameters or else all other parameters have default arguments</p>
</blockquote>

<p>So <a href="http://www.cplusplus.com/reference/map/map/map/">the following</a> list of constructors for <code>std::map</code> indicates </p>

<p><code>map (initializer_list&lt;value_type&gt; il,
     const key_compare&amp; comp = key_compare(),
     const allocator_type&amp; alloc = allocator_type())</code>;</p>

<p>is the candidate function, <code>value_type</code> in this case is <code>pair&lt;const type_index, std::string&gt;</code>. Lastly from <code>13.3.3.1.5</code>: </p>

<blockquote>
  <p>If the parameter type is <code>std::initializer_list&lt;X&gt;</code> or “array of <code>X</code>”135 and all the elements of the initializer list can be implicitly converted to <code>X</code>, the implicit conversion sequence is the worst conversion necessary to convert an element of the list to <code>X</code>.</p>
</blockquote>

<p>So it is a valid conversion as long as the elements of the braced-list implicitly convert to <code>pair&lt;const type_index, std::string&gt;</code>. But those elements are also braced-lists themselves. <code>Pair</code> does not take an initializer-list constructor, <a href="http://en.cppreference.com/w/cpp/utility/pair/pair">from here</a> it seems that copy-initialization from a braced-init list uses the second part of <code>13.3.1.7</code> to construct the object. So the following:</p>

<pre><code>pair&lt;const type_index, std::string&gt; p = {typeid(int), "int"}
</code></pre>

<p>becomes:</p>

<pre><code>pair&lt;const type_index, std::string&gt; p(typeid(int), "int")
</code></pre>

<p>but is this considered an implicit conversion? How can use of a two-argument constructor be considered an implicit conversion? What are the standard's comments on this?</p>