P0017R1 Extension to aggregate initialization

Editorially added punctuation, changed 'aggregate' to a definition,
replaced additional 'member's with 'element's,
fixed referenced clause in [diff.cpp14],
removed hyphen from aggregate-initialization,
corrected the text in [diff.cpp14] to more accurately describe the
incompatibility with C++14.

Author: Dawn Perchik

source/compatibility.tex

@@ -1515,6 +1515,28 @@
 int x = f(g1, g2);    // ill-formed; previously well-formed
 \end{codeblock}
 
+\ref{dcl.init.aggr}
+\change Definition of an aggregate is extended
+to apply to user-defined types with base classes.
+\rationale To increase convenience of aggregate initialization.
+\effect
+Valid \CppXIV code may fail to compile or produce different results in this
+International Standard; initialization from an empty initializer list will
+perform aggregate initialization instead of invoking a default constructor
+for the affected types:
+\begin{codeblock}
+struct derived;
+struct base {
+  friend struct derived;
+private: 
+  base();
+};
+struct derived : base {};
+
+derived d1{};       // Error. The code was well-formed before.
+derived d2;         // still OK
+\end{codeblock}
+
 \rSec2[diff.cpp14.depr]{Annex~\ref{depr}: compatibility features}
 
 \change

source/declarators.tex

@@ -2849,19 +2849,47 @@
 \indextext{\idxcode{\{\}}!initializer list}
 
 \pnum
-An
-\term{aggregate}
-is an array or a class (Clause~\ref{class}) with no
-user-provided constructors (\ref{class.ctor}),
+An \defn{aggregate} is an array or a class (Clause~\ref{class}) with
+\begin{itemize}
+\item
+no user-provided constructors~(\ref{class.ctor})
+(including those inherited~(\ref{namespace.udecl}) from a base class),
+\item
 no private or protected non-static data members (Clause~\ref{class.access}),
-no base classes (Clause~\ref{class.derived}),
-and no virtual functions (\ref{class.virtual}).
+\item
+no virtual functions~(\ref{class.virtual}), and
+\item
+no virtual, private, or protected base classes~(\ref{class.mi}).
+\end{itemize}
+\enternote
+Aggregate initialization does not allow accessing
+protected and private base class' members or constructors.
+\exitnote
+
+\pnum
+\indextext{aggregate!elements}%
+The \term{elements} of an aggregate are:
+\begin{itemize}
+\item
+for an array, the array elements in increasing subscript order, or
+\item
+for a class, the direct base classes in declaration order
+followed by the direct members in declaration order.
+\end{itemize}
 
 \pnum
-When an aggregate is initialized by an initializer list, as specified in~\ref{dcl.init.list}, the elements of the initializer list are taken as initializers
-for the members of the aggregate,
-in increasing subscript or member order.
-Each member is copy-initialized from the corresponding \grammarterm{initializer-clause}. If the \grammarterm{initializer-clause} is an expression and a narrowing conversion~(\ref{dcl.init.list}) is required to convert the expression, the program is ill-formed. \enternote If an \grammarterm{initializer-clause} is itself an initializer list, the member is list-initialized, which will result in a recursive application of the rules in this section if the member is an aggregate. \exitnote
+When an aggregate is initialized by an initializer list
+as specified in~\ref{dcl.init.list},
+the elements of the initializer list are taken as initializers
+for the elements of the aggregate, in order.
+Each element is copy-initialized
+from the corresponding \grammarterm{initializer-clause}.
+If the \grammarterm{initializer-clause} is an expression and
+a narrowing conversion~(\ref{dcl.init.list}) is required
+to convert the expression, the program is ill-formed.
+\enternote If an \grammarterm{initializer-clause} is itself an initializer list,
+the element is list-initialized, which will result in a recursive application
+of the rules in this section if the element is an aggregate. \exitnote
 \enterexample
 \begin{codeblock}
 struct A {
@@ -2872,14 +2900,38 @@
   } b;
 } a = { 1, { 2, 3 } };
 \end{codeblock}
-
 initializes
 \tcode{a.x}
 with 1,
 \tcode{a.b.i}
 with 2,
 \tcode{a.b.j}
 with 3.
+
+\begin{codeblock}
+struct base1 { int b1, b2 = 42; };
+struct base2 {
+  B() {
+    b3 = 42;
+  }
+  int b3;
+};
+struct derived : base1, base2 {
+  int d;
+};
+
+derived d1{{1, 2}, {}, 4};
+derived d2{{}, {}, 4};
+\end{codeblock}
+initializes
+\tcode{d1.b1} with 1,
+\tcode{d1.b2} with 2,
+\tcode{d1.b3} with 42,
+\tcode{d1.d} with 4, and
+\tcode{d2.b1} with 0,
+\tcode{d2.b2} with 42,
+\tcode{d2.b3} with 42,
+\tcode{d2.d} with 4.
 \exitexample
 
 \pnum
@@ -2955,7 +3007,7 @@
 
 \pnum
 If there are fewer \grammarterm{initializer-clause}{s} in the list than there
-are members in the aggregate, then each member not explicitly initialized
+are elements in the aggregate, then each element not explicitly initialized
 shall be initialized from its default member initializer~(\ref{class.mem}) or,
 if there is no default member initializer, from an empty
 initializer list~(\ref{dcl.init.list}).
@@ -3004,12 +3056,12 @@
 \exitexample
 
 \pnum
-If an aggregate class \tcode{C} contains a subaggregate member
-\tcode{m} that has no members for purposes of aggregate initialization,
-the \grammarterm{initializer-clause} for \tcode{m} shall not be
+If an aggregate class \tcode{C} contains a subaggregate element
+\tcode{e} that has no elements for purposes of aggregate initialization,
+the \grammarterm{initializer-clause} for \tcode{e} shall not be
 omitted from an \grammarterm{initializer-list} for an object of type
 \tcode{C} unless the \grammarterm{initializer-clause}{s} for all
-members of \tcode{C} following \tcode{m} are also omitted.
+elements of \tcode{C} following \tcode{e} are also omitted.
 \enterexample
 
 \begin{codeblock}
@@ -3084,20 +3136,20 @@
 begins with a left brace,
 then the succeeding comma-separated list of
 \grammarterm{initializer-clause}{s}
-initializes the members of a subaggregate;
+initializes the elements of a subaggregate;
 it is erroneous for there to be more
 \grammarterm{initializer-clause}{s}
-than members.
+than elements.
 If, however, the
 \grammarterm{initializer-list}
 for a subaggregate does not begin with a left brace,
 then only enough
 \grammarterm{initializer-clause}{s}
-from the list are taken to initialize the members of the subaggregate;
+from the list are taken to initialize the elements of the subaggregate;
 any remaining
 \grammarterm{initializer-clause}{s}
-are left to initialize the next member of the aggregate
-of which the current subaggregate is a member.
+are left to initialize the next element of the aggregate
+of which the current subaggregate is an element.
 \enterexample
 
 \begin{codeblock}
@@ -3156,16 +3208,16 @@
 
 \pnum
 All implicit type conversions (Clause~\ref{conv}) are considered when
-initializing the aggregate member with an \grammarterm{assignment-expression}.
+initializing the element with an \grammarterm{assignment-expression}.
 If the
 \grammarterm{assignment-expression}
-can initialize a member, the member is initialized.
-Otherwise, if the member is itself a subaggregate,
+can initialize an element, the element is initialized.
+Otherwise, if the element is itself a subaggregate,
 brace elision is assumed and the
 \grammarterm{assignment-expression}
-is considered for the initialization of the first member of the subaggregate.
+is considered for the initialization of the first element of the subaggregate.
 \enternote As specified above, brace elision cannot apply to
-subaggregates with no members for purposes of aggregate initialization; an
+subaggregates with no elements for purposes of aggregate initialization; an
 \grammarterm{initializer-clause} for the entire subobject is
 required.\exitnote
 
@@ -3202,7 +3254,7 @@
 \pnum
 \indextext{initialization!array~of class~objects}%
 \enternote
-An aggregate array or an aggregate class may contain members of a
+An aggregate array or an aggregate class may contain elements of a
 class type with a user-provided constructor (\ref{class.ctor}).
 Initialization of these aggregate objects is described in~\ref{class.expl.init}.
 \exitnote