Aggregate Initialization with Inheritance

Aggregate initialization in C++ has specific rules when it comes to inheritance. Generally, aggregate initialization cannot be used directly with derived classes if they have base classes that are not aggregates themselves. Let's delve into this with an example.

First, consider a base class and a derived class:

1#include <iostream>
2
3struct Base {
4  int a;
5};
6
7struct Derived : public Base {
8  int b;
9};
10
11int main() {
12  Derived d{1, 2};  
13  std::cout << "a=" << d.a
14    << ", b=" << d.b;
15}

1a=1, b=2

In this example, Base is an aggregate because it has no user-defined constructors or private members. Consequently, Derived can also use aggregate initialization, inheriting the properties of Base.

If Base has private members or user-defined constructors, Derived cannot use aggregate initialization directly:

1#include <iostream>
2
3struct Base {
4  int a;
5
6  Base() {};  
7};
8
9struct Derived : public Base {
10  int b;
11};
12
13int main() {
14  Derived d{1, 2};  
15}

1error: 'initializing': cannot convert from 'int' to 'Base'

This code will not compile because Base now has a user-defined constructor, making it non-aggregate. Therefore, Derived also becomes non-aggregate, and aggregate initialization cannot be used.

To properly initialize such classes, you must use constructors:

1#include <iostream>
2
3struct Base {
4  int a;
5
6  Base(){};
7  Base(int x) : a{x} {} 
8};
9
10struct Derived : public Base {
11  Derived(int x, int y) : Base{x}, b{y} {}
12  int b;
13};
14
15int main() {
16  Derived d{1, 2};
17  std::cout << "a=" << d.a
18    << ", b=" << d.b;
19}

1a=1, b=2

In this code, Derived has a constructor that initializes the base class Base and its own member b. This is the correct approach when dealing with inheritance and aggregate initialization limitations.

Another point to consider is multiple inheritance:

1#include <iostream>
2
3struct Base1 {
4  int a;
5};
6
7struct Base2 {
8  int b;
9};
10
11struct Derived : public Base1, public Base2 {
12  int c;
13};
14
15int main() {
16  Derived d{{1}, {2}, 3};  
17  std::cout << "a=" << d.a
18    << ", b=" << d.b
19    << ", c=" << d.c;
20}

1a=1, b=2, c=3

In multiple inheritance, you can still use aggregate initialization if all base classes and the derived class are aggregates. Each base class is initialized in the order of inheritance.

In summary, aggregate initialization works with inheritance as long as all involved classes are aggregates. When base classes have private members or user-defined constructors, you must use constructors for initialization in derived classes.