What is expected lifetime of std::intializer_list object in C++14?

Question

Please consider this simplified c++14 program:

#include <iostream>

struct A
{
    A() { std::cout << "A() "; }
    ~A() { std::cout << "~A() "; }
};

int main()
{
    auto l = std::initializer_list<A>{A()};
    std::cout << ". ";
}

https://gcc.godbolt.org/z/1GWvGfxne

GCC prints here

A() . ~A()

Meaning that std::initializer_list is destructed at the end of scope.

Clang prints:

A() ~A() .

Destroying std::initializer_list in the line where it is constructed.

Are both compiler behave correctly here or one of them is wrong?

If you enable verbose warnings, Clang will tell you the problem. See e.g. [on the compiler explorer](https://godbolt.org/z/e5GTofe95). — Some programmer dude, Jul 16 '21 at 11:28
Thanks, I see. Still the question is why GCC behaves differently. — Fedor, Jul 16 '21 at 11:35
Related: https://stackoverflow.com/questions/15286450/lifetime-of-a-stdinitializer-list-return-value — Jodocus, Jul 16 '21 at 11:39

StoryTeller - Unslander Monica · Accepted Answer · 2021-07-16T11:43:11.473

It's subtle.

A std::initializer_list is backed by an underlying array (produced by the compiler). This array is a like a temporary object, and the std::initializer_list is a sort of reference type that binds to it. So it will extend the temporary array's lifetime so long as the "reference" exist.

In C++14, we do not have guaranteed copy elision. So what should happen is as though std::initializer_list<A>{A()} produced a temporary initializer_list, bound another temporary array to it, and copied the temporary initializer_list to l.

std::initializer_list behaves like a regular reference, as far as lifetime extension is concerned. Only the original reference extends the lifetime, and our original is temporary itself. So the underlying array goes out of existence at the end of the full expression containing the initialization of l. Clang is the correct one.

Direct-initialization ...

std::initializer_list<A> l {A()};

... produces the same output on both compilers.

Meanwhile, your original code behaves the same on GCC and Clang when compiling for C++17.

Upon reading this, it's hard to prohibit the thought to oneself that C++ initialization is an utter mess... — Jodocus, Jul 16 '21 at 11:42
@Jodocus - [It's a known fact](https://i.imgur.com/3wlxtI0.gifv). — StoryTeller - Unslander Monica, Jul 16 '21 at 11:44

score 0 · Answer 2 · answered Jul 16 '21 at 11:48

0

According to cppreference:

Until the resolution of CWG issue 1696, a temporary is permitted to bound to a reference member in a constructor initializer list, and it persists only until the constructor exits, not as long as the object exists. Such initialization is ill-formed since CWG 1696, although many compilers still support it (a notable exception is clang).

answered Jul 16 '21 at 11:48

Boris Uskov

97
5

1

i dont think this is relevant. The quote is about a temporary binding to a reference member in constructors initiaizer list. – 463035818_is_not_an_ai Jul 16 '21 at 11:50

What is expected lifetime of std::intializer_list object in C++14?

2 Answers2