Extension to aggregate initialization

I. Introduction

C++11 introduced aggregate initialization and the new succinct syntax is very much appreciated. It removes boiler plate constructor code that is otherwise needed for simple types such as the following:

struct user
{
    uint32_t id_;
    std::string name_;
};

user u1{10, "Alice"};

The Standard states that it is possible to initialize instances of such simple structs provided that there are no base classes. This paper asks for an amendment to allow base classes, provided that they are default-constructible.

II. Motivation

The following case comes up frequently when using template-based libraries such as Boost StateChart. The following is needed to define a state with a single member:

struct status_event : boost::statechart::event
{
    status_event(uint32 seq) : seq_(seq)     // manually written boiler plate
    {
    }

    uint32 seq_;
};

post_event(status_event{42});

As per 8.5.1 [dcl.init.aggr], it is possible to initialize instances of simple structs and there are provisions for member structs (2), empty members (9) and even brace elision (13). However, Clause (1) states that none of this goodness works when there are base classes.

It would be really useful to initialize aggregate classes even when they have a trivially constructible base class.

III. Scope

No initialization proposal can be complete without examining basic aggregates of integral types and value initialization. Consider the following case:

struct A { int a1, a2; };
struct B : A { int b1; };

B inst{1};

A similar situation occurs when mixing user-defined constructors with the compiler-provided ones. Consider the following case:

struct A { int a1, a2 = 1; };
struct B { 
    B() {
        b1 = /* get a value somewhere */;
    }
    int b1;
};
struct C : A, B {
  int c1;
};

C inst{1};

IV. Technical specifications

Edit section 8.5.1 "Aggregates [dcl.init.aggr]"

1. An aggregate is an array or a class (Clause 9) with no user-provided constructors (12.1), no private or protected non-static data members (Clause 11), no base classes (Clause 10), and no virtual functions (10.3) , and only default-constructible base classes.
2. Default-constructible base classes shall be initialized from an empty initializer list (8.5.4).

V. Acknowledgments