Why does C++11 not support designated initializer lists as C99? [closed]

by

On July 15 ’17 P0329R4 was accepted into the c++20 standard: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0329r4.pdf
This brings limited support for c99‘s Designated Initializers. This limitation is described as follows by C.1.7[diff.decl].4, given:

struct A { int x, y; };
struct B { struct A a; };

The following Designated Initializations, which are valid in C, are restricted in C++:

  • struct A a = { .y = 1, .x = 2 } is invalid in C++ because designators must appear in the declaration order of the data members
  • int arr[3] = { [1] = 5 } is invalid in C++ because array designated initialization is not supported
  • struct B b = {.a.x = 0} is invalid in C++ because designators cannot be nested
  • struct A c = {.x = 1, 2} is invalid in C++ because either all or none of the data members must be initialized by designators

For c++17 and earlier Boost actually has support for Designated Intializers and there have been numerous proposals to add support to the c++ standard, for example: n4172 and Daryle Walker’s Proposal to Add Designation to Initializers. The proposals cite implementation of c99‘s Designated Initializers in Visual C++, gcc, and Clang claiming:

We believe the changes will be relatively straightforward to implement

But the standard committee repeatedly rejects such proposals, stating:

EWG found various problems with the proposed approach, and didn’t think it’s feasible to try solving the problem, as it has been tried many times and every time it has failed

Ben Voigt’s comments have helped me to see the insurmountable problems with this approach; given:

struct X {
    int c;
    char a;
    float b;
};

What order would these functions be called in in c99: struct X foo = {.a = (char)f(), .b = g(), .c = h()}? Surprisingly, in c99:

The order of evaluation of the subexpressions in any initializer is indeterminately sequenced [1]

(Visual C++, gcc, and Clang seem to have an agreed upon behavior as they will all make the calls in this order:)

  1. h()
  2. f()
  3. g()

But the indeterminate nature of the standard means that if these functions had any interaction the resulting program state would also be indeterminate, and the compiler wouldn’t warn you: Is there a Way to Get Warned about Misbehaving Designated Initializers?

c++ does have stringent initializer-list requirements 11.6.4[dcl.init.list]4:

Within the initializer-list of a braced-init-list, the initializer-clauses, including any that result from pack expansions (17.5.3), are evaluated in the order in which they appear. That is, every value computation and side effect associated with a given initializer-clause is sequenced before every value computation and side effect associated with any initializer-clause that follows it in the comma-separated list of the initializer-list.

So c++ support would have required this to be executed in the order:

  1. f()
  2. g()
  3. h()

Breaking compatibility with previous c99 implementations.
As discussed above, this issue has been circumvented by the limitations on Designated Initializers accepted into c++20. They provide a standardized behavior, guaranteeing the execution order of Designated Initializers.

More Related Contents:

  1. Why is list initialization (using curly braces) better than the alternatives?
  2. Is type-punning through a union unspecified in C99, and has it become specified in C11?
  3. How to emulate C array initialization “int arr[] = { e1, e2, e3, … }” behaviour with std::array?
  4. What are the differences between C-like, constructor, and uniform initialization?
  5. Visual Studio support for new C / C++ standards?
  6. Why can’t simple initialize (with braces) 2D std::array? [duplicate]
  7. What are the advantages of list initialization (using curly braces)?
  8. C++11 allows in-class initialization of non-static and non-const members. What changed?
  9. How to initialize std::array elegantly if T is not default constructible?
  10. Default initialization of std::array?
  11. C++11: Correct std::array initialization?
  12. Now that we have std::array what uses are left for C-style arrays?
  13. C++11 member initializer list vs in-class initializer?
  14. Is there a meaningful distinction between freestanding and hosted implementations?
  15. Initializing container of unique_ptrs from initializer list fails with GCC 4.7
  16. Set all bytes of int to (unsigned char)0, guaranteed to represent zero?
  17. What is the default C -std standard version for the current GCC (especially on Ubuntu)?
  18. too many initializers for ‘int [0]’ c++
  19. Has the new C++11 member initialization feature at declaration made initialization lists obsolete?
  20. Different ways of initializing an object in c++
  21. Is int main() { } (without “void”) valid and portable in ISO C?
  22. What’s the difference between parentheses and braces in c++ when constructing objects
  23. Initialization difference with or without curly braces in C++
  24. Is there a way to statically-initialize a dynamically-allocated array in C++?
  25. Is there any option to switch between C99 and C11 C standards in Visual Studio?
  26. Initializing an std::array of non-default-constructible elements?
  27. Dynamic array allocation on stack in C
  28. When should you use constexpr capability in C++11?
  29. Is a `=default` move constructor equivalent to a member-wise move constructor?
  30. how to avoid static member function when using gsl with c++

Leave a Comment