Why isn’t `std::initializer_list` defined as a literal type?

by

The standard committee seems to intend on initializer_list being a literal type. However, it doesn’t look like it’s an explicit requirement, and seems to be a bug in the standard.

From § 3.9.10.5:

A type is a literal type if it is:
– a class type (Clause 9) that has all of the following properties:
– – it has a trivial destructor,
– – it is an aggregate type (8.5.1) or has at least one constexpr constructor or constructor template that is not a copy or move constructor, and
– – all of its non-static data members and base classes are of non-volatile literal types.

From § 18.9.1:

namespace std {
  template<class E> class initializer_list {
  public:
    /* code removed */
    constexpr initializer_list() noexcept;
    // No destructor given, so trivial
    /* code removed */
  };
}

This satisfies the first and second requirements.

For the third requirement though:

From § 18.9.2 (emphasis mine):

An object of type initializer_list<E> provides access to an array of objects of type const E. [Note: A pair of pointers or a pointer plus a length would be obvious representations for initializer_list. initializer_list is used to implement initializer lists as specified in 8.5.4. Copying an initializer list does not copy the underlying elements.
—end note]

So there is no requirement for the private members of the implementation of initializer_list to be non-volatile literal types; however, because they mention that they believe a pair of pointers or a pointer and a length would be the “obvious representation,” they probably didn’t consider that someone might put something non-literal in the members of initializer_list.

I’d say that it’s both a bug in clang and the standard, probably.

More Related Contents:

  1. Understanding the example on lvalue-to-rvalue conversion
  2. Is it legal to declare a constexpr initializer_list object?
  3. Self-initialization of a static constexpr variable, is it well-formed?
  4. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  5. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  6. static_assert dependent on non-type template parameter (different behavior on gcc and clang)
  7. Is a pointer with the right address and type still always a valid pointer since C++17?
  8. Deleted default constructor. Objects can still be created… sometimes
  9. Are multiple mutations of the same variable within initializer lists undefined behavior pre C++11
  10. Can I obtain C++ type names in a constexpr way?
  11. Are notes and examples in the core language specification of the C++ Standard non-normative?
  12. Static member access in constant expressions
  13. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  14. Compile-time or runtime detection within a constexpr function
  15. Can I Reference Previous Members of an Initializer List?
  16. Why doesn’t an if constexpr make this core constant expression error disappear?
  17. Will consteval functions allow template parameters dependent on function arguments?
  18. Calling initializer_list constructor via make_unique/make_shared
  19. Is a constexpr array necessarily odr-used when subscripted?
  20. Why was the space character not chosen for C++14 digit separators?
  21. Throw in constexpr function
  22. Classes with both template and non-template conversion operators in the condition of switch statement
  23. Why does constexpr static member (of type class) require a definition?
  24. Why is `make_unique` disallowed?
  25. Injected class name compiler discrepancy
  26. What changes to C++ made copy initialization work for class with explicit constructor?
  27. Directly write into char* buffer of std::string
  28. Implementation C++14 make_integer_sequence
  29. Compile c++14-code with g++
  30. Why don’t I need to specify “typename” before a dependent type in C++20?

Leave a Comment