11 Overloading [over]

11.3 Overload resolution [over.match]

11.3.1 Candidate functions and argument lists [over.match.funcs]

11.3.1.8 Class template argument deduction [over.match.class.deduct]

1
#
When resolving a placeholder for a deduced class type ([dcl.type.class.deduct]) where the template-name names a primary class template C, a set of functions and function templates is formed comprising:
  • (1.1)
    If C is defined, for each constructor of C, a function template with the following properties:
    • (1.1.1)
      The template parameters are the template parameters of C followed by the template parameters (including default template arguments) of the constructor, if any.
    • (1.1.2)
      The types of the function parameters are those of the constructor.
    • (1.1.3)
      The return type is the class template specialization designated by C and template arguments corresponding to the template parameters of C.
  • (1.2)
    If C is not defined or does not declare any constructors, an additional function template derived as above from a hypothetical constructor C().
  • (1.3)
    An additional function template derived as above from a hypothetical constructor C(C), called the copy deduction candidate.
  • (1.4)
    For each deduction-guide, a function or function template with the following properties:
2
#
Initialization and overload resolution are performed as described in [dcl.init] and [over.match.ctor], [over.match.copy], or [over.match.list] (as appropriate for the type of initialization performed) for an object of a hypothetical class type, where the selected functions and function templates are considered to be the constructors of that class type for the purpose of forming an overload set, and the initializer is provided by the context in which class template argument deduction was performed.
As an exception, the first phase in [over.match.list] (considering initializer-list constructors) is omitted if the initializer list consists of a single expression of type cv U, where U is a specialization of C or a class derived from a specialization of C.
If the function or function template was generated from a constructor or deduction-guide that had an explicit-specifier, each such notional constructor is considered to have that same explicit-specifier.
All such notional constructors are considered to be public members of the hypothetical class type.
3
#
[ Example
: 
template <class T> struct A {
  explicit A(const T&, ...) noexcept;               // #1
  A(T&&, ...);                                      // #2
};

int i;
A a1 = { i, i };    // error: explicit constructor #1 selected in copy-list-initialization during deduction,
                    // cannot deduce from non-forwarding rvalue reference in #2

A a2{i, i};         // OK, #1 deduces to A<int> and also initializes
A a3{0, i};         // OK, #2 deduces to A<int> and also initializes
A a4 = {0, i};      // OK, #2 deduces to A<int> and also initializes

template <class T> A(const T&, const T&) -> A<T&>;  // #3
template <class T> explicit A(T&&, T&&) -> A<T>;    // #4

A a5 = {0, 1};      // error: explicit deduction guide #4 selected in copy-list-initialization during deduction
A a6{0,1};          // OK, #4 deduces to A<int> and #2 initializes
A a7 = {0, i};      // error: #3 deduces to A<int&>, #1 and #2 declare same constructor
A a8{0,i};          // error: #3 deduces to A<int&>, #1 and #2 declare same constructor

template <class T> struct B {
  template <class U> using TA = T;
  template <class U> B(U, TA<U>);
};

B b{(int*)0, (char*)0};         // OK, deduces B<char*>
— end example
 ]