CTAD，initializer_list，非显式构造函数，以及对函数的调用

Question

Basically, what I want is something like multi_types std::initializer_list

template<typename ...As>
struct Foo {
Foo(As...){}
};

template<typename ...As>
void f(Foo<As...>) {}

int main() {
  f(Foo{5, 3.f}); // 1) compile
  f({}); // 2) compile
  f({5, 3}); // 3) error
  f({5, 3.8}); // 4) error
  return 0;
}

I do understand why the first example compiles. However, I do not understand why the second compiles but the others don't. To me, the second should also not compile if third and fourth do not compile. Is there a way to make third and fourth compile?

Answer 1

However, I do not understand why the second compiles but the others don't [compile].

Examples 3 and 4 fail to compile because the deduced template arguments are different from what you expect.

When you write a call ( f({5, 3}) ) to a function template template<typename ...As> void f(Foo<As...>) , the compiler needs to deduce any missing template arguments ( ...As ). These missing template arguments are first deduced by comparing the function arguments ( {5, 3} ) with the function parameters ( Foo<As...> ). If a function argument is an initializer list ( {5, 3} ) [1], template argument deduction is skipped for the function parameter ( Foo<As...> ):

N4659 [temp.deduct.call] 17.8.2.1(1):

[...] an initializer list argument causes the parameter to be considered a non-deduced context (17.8.2.5).

N4659 [temp.deduct.type] 17.8.2.5(5.6):

[Non-deduced contexts include a] function parameter for which the associated argument is an initializer list (11.6.4) [...]

Because the trailing template parameter pack ( As... ) is not deduced by any function arguments, it is deduced as empty:

N4659 [temp.arg.explicit] 17.8.1(3):

A trailing template parameter pack (17.5.3) not otherwise deduced will be deduced to an empty sequence of template arguments.

For f({5, 3}) , the compiler deduces that the template arguments are <> (empty), thus the specialization being called is void f(Foo<>) . Important: This specialization is chosen regardless of what's inside the initializer list. This explains the diagnostics given by the compiler:

Clang:
error: no matching function for call to 'f'
note: candidate function [with As = <>] not viable: cannot convert initializer list argument to 'Foo<>'

GCC:
error: could not convert '{5, 3}' from '' to 'Foo<>'

MSVC:
error C2664: 'void f<>(Foo<>)': cannot convert argument 1 from 'initializer list' to 'Foo<>'
note: No constructor could take the source type, or constructor overload resolution was ambiguous

In a function call, function parameters are initialized using copy-initialization from the function arguments. The following statements initialize a variable using the same rules that your examples initialize the parameter of f :

Foo<> x = {};        // Example 2
Foo<> x = {5, 3};    // Example 3
Foo<> x = {5, 3.8};  // Example 4

[1] and, in short, if the function parameter is neither std::initializer_list<T> nor T[n]

Answer 2

Is there a way to make third and fourth compile?

I think there is no way to change f or Foo to make your fourth example compile.

To make your third example compile, you can add an overload of f which takes an array:

#include <cstddef>
#include <utility>

#define EXPLICIT_TEMPLATE_ARGUMENTS 1
//#define EXPLICIT_TEMPLATE_ARGUMENTS 0

#if EXPLICIT_TEMPLATE_ARGUMENTS
template<class T, std::size_t>
struct identity {
    using type = T;
};
#endif

template<class ...As>
struct Foo {
    Foo(As...);
};

template<class ...As>
void f(Foo<As...>);

template<class A, std::size_t N, std::size_t ...Indexes>
void f_helper(A const (&as)[N], std::index_sequence<Indexes...>) {
    static_assert(N == sizeof...(Indexes));
#if EXPLICIT_TEMPLATE_ARGUMENTS
    // Example pack expansions:
    // return f<>(Foo<>{});
    // return f<A>(Foo<A>{as[0]});
    // return f<A, A>(Foo<A, A>{as[0], as[1]});
    return f<typename identity<A, Indexes>::type...>(Foo<typename identity<A, Indexes>::type...>{as[Indexes]...});
#else
    // Example pack expansions:
    // return f(Foo{});
    // return f(Foo{as[0]});
    // return f(Foo{as[0], as[1]});
    return f(Foo{as[Indexes]...});
#endif
}

// Call as: f({x, y, z})
template<class A, std::size_t N>
void f(A const (&as)[N]) {
    return f_helper<A, N>(as, std::make_index_sequence<N>());
}

int main() {
  f(Foo{5, 3.f}); // 1) compile
  f({}); // 2) compile
  f({5, 3}); // 3) compile (was: error)
  f({5, 3.8}); // 4) error

  return 0;
}