const auto std::initializer_list difference between Clang and GCC

by

GCC bug. [dcl.spec.auto]/p7 (quoting N4527):

When a variable declared using a placeholder type is initialized,
[…] the deduced return type or variable type is determined from the
type of its initializer. […] Otherwise, let T be the declared type
of the variable […]. If the placeholder is the auto
type-specifier, the deduced type is determined using the rules for template argument deduction. If the initialization is
direct-list-initialization […]. […] Otherwise, obtain P from T by replacing the occurrences of auto with either a new invented
type template parameter U or, if the initialization is
copy-list-initialization, with std::initializer_list<U>. Deduce a value for U using the rules of template argument deduction from a
function call (14.8.2.1), where P is a function template parameter
type and the corresponding argument is the initializer […]. If the
deduction fails, the declaration is ill-formed. Otherwise, the type
deduced for the variable or return type is obtained by substituting
the deduced U into P.

Thus, in const auto l2 = { 1, 2, 3 };, deduction is performed as if for the function template

template<class U> void meow(const std::initializer_list<U>);

given the call meow({1, 2, 3}).

Now consider the const-less case auto l3 = { 1, 2, 3 }; (which GCC correctly deduces as std::initializer_list<int>). Deduction in this case is performed as if for the function template

template<class U> void purr(std::initializer_list<U>);

given the call purr({1, 2, 3}).

Since top-level cv-qualification of function parameters are ignored, it should be obvious that the two deduction should yield the same type.

[temp.deduct.call]/p1:

Template argument deduction is done by comparing each function
template parameter type (call it P) with the type of the
corresponding argument of the call (call it A) as described below.
If P is a dependent type, removing references and cv-qualifiers from
P gives std::initializer_list<P'> […] for some P' […] and
the argument is a non-empty initializer list (8.5.4), then deduction
is performed instead for each element of the initializer list, taking
P' as a function template parameter type and the initializer element
as its argument.

Deducing P' (which is U) against 1, 2, or 3, all literals of type int, obviously yields int.

More Related Contents:

  1. constexpr and initialization of a static const void pointer with reinterpret cast, which compiler is right?
  2. Can I use C++11 with Xcode?
  3. What are the differences between -std=c++11 and -std=gnu++11?
  4. Overloaded lambdas in C++ and differences between clang and gcc
  5. Is there a compiler bug exposed by my implementation of an is_complete type trait?
  6. gcc can compile a variadic template while clang cannot
  7. Why can’t I move std::ofstream?
  8. What does the standard library guarantee about self move assignment?
  9. when g++ static link pthread, cause Segmentation fault, why?
  10. How to declare a vector of atomic in C++
  11. Is std::string ref-counted in GCC 4.x / C++11?
  12. std::optional specialization for reference types
  13. What is the difference between MinGW, MinGW-w64 and MinGW-builds?
  14. std::put_time implementation status in GCC?
  15. GNU C++ how to check when -std=c++0x is in effect?
  16. What is the default hash function used in C++ std::unordered_map?
  17. Clang doesn’t see basic headers
  18. C++11: How to alias a function? [duplicate]
  19. How do I erase elements from STL containers?
  20. What happens when you call data() on a std::vector?
  21. When will Gnu C++ support C++11 without explicitly asking for it?
  22. std::thread error (thread not member of std)
  23. Why can’t I replace std::map with std::unordered_map
  24. Are lambdas inlined like functions in C++?
  25. Using libstdc++ compiled libraries with clang++ -stdlib=libc++
  26. Can nullptr be emulated in gcc?
  27. error for hash function of pair of ints
  28. Should std::unique_ptr be permitted
  29. stl container with std::unique_ptr’s vs boost::ptr_container
  30. STL algorithms: Why no additional interface for containers (additional to iterator pairs)?

Leave a Comment