16 Overloading [over]

A set of functions and function templates is formed comprising:

• (1.1)

  For each constructor of the primary class template designated by the template-name, if the template is defined, a function template with the following properties:

  • (1.1.1)

    The template parameters are the template parameters of the class template 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 the template-name and template arguments corresponding to the template parameters obtained from the class template.

• (1.2)

  If the primary class template 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:

  • (1.4.1)

    The template parameters, if any, and function parameters are those of the deduction-guide.

  • (1.4.2)

    The return type is the simple-template-id of the deduction-guide.

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. Each such notional constructor is considered to be explicit if the function or function template was generated from a constructor or deduction-guide that was declared explicit. All such notional constructors are considered to be public members of the hypothetical class type.

[ 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 ]