lifetime of a std::initializer_list return value

by

std::initializer_list is not a container, don’t use it to pass values around and expect them to persist

DR 1290 changed the wording, you should also be aware of 1565 and 1599 which aren’t ready yet.

Then the return value’s array should also survive into the calling function, and it should be possible to preserve it by binding it to a named reference.

No, that doesn’t follow. The array’s lifetime doesn’t keep being extended along with the initializer_list. Consider:

struct A {
    const int& ref;
    A(const int& i = 0) : ref(i) { }
};

The reference i binds to the temporary int, and then the reference ref binds to it as well, but that doesn’t extend the lifetime of i, it still goes out of scope at the end of the constructor, leaving a dangling reference. You don’t extend the underlying temporary’s lifetime by binding another reference to it.

Your code might be safer if 1565 is approved and you make il a copy not a reference, but that issue is still open and doesn’t even have proposed wording, let alone implementation experience.

Even if your example is meant to work, the wording regarding lifetime of the underlying array is obviously still being improved and it will take a while for compilers to implement whatever final semantics are settled on.

More Related Contents:

  1. Which greedy initializer-list examples are lurking in the Standard Library?
  2. Why is list initialization (using curly braces) better than the alternatives?
  3. Can I list-initialize a vector of move-only type?
  4. initializer_list and move semantics
  5. Initializer lists and RHS of operators
  6. initializer_list and template type deduction
  7. What are the advantages of list initialization (using curly braces)?
  8. Initializing a member array in constructor initializer
  9. When to use the brace-enclosed initializer?
  10. Why does auto x{3} deduce an initializer_list?
  11. How do I initialize a member array with an initializer_list?
  12. Brace-enclosed initializer list constructor
  13. Order of evaluation of elements in list-initialization
  14. Are multiple mutations within initializer lists undefined behavior?
  15. Why does ‘std::vector b{2};’ create a 1-element vector, and not a 2-element one?
  16. Why doesn’t my template accept an initializer list
  17. How to construct std::array object with initializer list? [duplicate]
  18. Initializer-list-constructing a vector of noncopyable (but movable) objects
  19. Why does the standard differentiate between direct-list-initialization and copy-list-initialization?
  20. Is it legal to declare a constexpr initializer_list object?
  21. Why do auto and template type deduction differ for braced initializers?
  22. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  23. C++11 initializer list fails – but only on lists of length 2
  24. Double delete in initializer_list vs 2013
  25. Why can’t I initialize a reference in an initializer list with uniform initialization?
  26. Range-based for with brace-initializer over non-const values?
  27. What would a std::map extended initializer list look like?
  28. Initialization difference with or without curly braces in C++
  29. C++ Copy constructor gets called instead of initializer_list
  30. Is it possible to invoke a user-defined conversion function via list-initialization?

Leave a Comment