Question

Lets say I have the following code in what we expect to become the next C++ standard:

int f(int x) 
{ 
  std::cout << x;
  return x * x; 
}

struct A
{
  A(int x) : m_x(x) {}
  int m_x;
};

struct B : A
{
  using A::A;
  B() : m_y(f(m_x)) {}
  int m_y;
};

int main()
{
  B(5);
}

Would this call the default constructor of B and print out 5 and set m_y = 25? Or will the default constructor of B not run, and leave m_y uninitialized?

And if the latter, what is the rationale behind not calling the B default constructor? It is quite clear that the A(int) B inherits only initialises A, and leaves B in an indeterminate state. Why would C++ choose undefined behaviour over simply calling the default constructor of B()? It largely defeats the purpose of the inheriting constructors feature.

Edit:

Perhaps this should be allowed:

using A::A : m_y(...) { std::cout << "constructing..." << std::endl; ...; }

Answer 1

using A::A; implicitly declares B(int) in the derived class. That is it.

The rest of your program should not work as you expect. Because you’re invoking B(int) with B(5), and that leaves m_y uninitialized.

See this example from Bjarne Stroustrup’s site:

struct B1 {
    B1(int) { }
};

struct D1 : B1 {
    using B1::B1; // implicitly declares D1(int)
    int x;
};

void test()
{
    D1 d(6);    // Oops: d.x is not initialized
    D1 e;       // error: D1 has no default constructor
}

http://www2.research.att.com/~bs/C++0xFAQ.html#inheriting

Another example from the same link:

struct D1 : B1 {
        using B1::B1;   // implicitly declares D1(int)
        int x{0};   // note: x is initialized
    };

    void test()
    {
        D1 d(6);    // d.x is zero
    }