Why Does the Lifetime of an `std::initializer_list` Return Value Differ Between GCC and Clang?

Lifetime of a std::initializer_list Return Value: GCC vs. Clang Behavior

In the provided code, you're returning an std::initializer_list from a function and observing unexpected destructor behavior. Specifically, the array returned from the function is destroyed before you can access its elements.

The underlying issue stems from the fact that, according to the C standard, an std::initializer_list has an array of elements that is constructed with the same lifetime as the initializer_list. This means that, by default, the array is destroyed at the end of the return statement in your function.

GCC's implementation adheres to this behavior, while Clang does not. Clang maintains the array's lifetime beyond the end of the return statement, which is not compliant with the standard. However, Clang's behavior appears inconsistent, as the object destructors are never called.

Copy-List-Initialization and Compiler Interpretations

The return statement with a braced-init-list initializes the return value via copy-list-initialization, which means it copy-initializes an existing object. In this case, a temporary initializer_list object is copy-initialized from the brace-enclosed list. Subsequently, another initializer_list object is copy-initialized from the first.

The standard states that the array's lifetime is the same as the initializer_list object, but as multiple copies of the initializer_list are created, it's unclear which object's lifetime determines the array's lifespan.

GCC interprets the standard by considering the lifetime of the returned initializer_list object, leading to the premature destruction of the array. However, the example provided in 8.5.4/6 suggests that the array's lifetime should extend to the end of the enclosing expression, including the receiving function.

Summary of Compiler Behaviors and Standard Ambiguity

• GCC: Follows the standard and destroys the array at the end of the return statement.
• Clang: Extends the array's lifetime beyond the return statement but fails to properly destroy object destructors.
• The standard is ambiguous regarding which initializer_list object determines the array's lifetime.

Recommendation

To avoid unexpected behavior, it's generally not recommended to return an std::initializer_list by value. If you need to pass a variable number of objects, consider using a container class, such as std::vector, instead.

The above is the detailed content of Why Does the Lifetime of an `std::initializer_list` Return Value Differ Between GCC and Clang?. For more information, please follow other related articles on the PHP Chinese website!