Ereditare costruttori in C++ 0x

Question

Diciamo che ho il seguente codice in ciò che ci aspettiamo di diventare il prossimo standard C++:

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); 
} 

sarebbe questo chiamare il costruttore di default di B e stampare 5 e impostare m_y = 25? O il costruttore predefinito di B non verrà eseguito e lascerà m_y non inizializzato?

E se quest'ultimo, qual è la logica dietro non chiamare il costruttore B predefinito? È abbastanza chiaro che A (int) B eredita solo inizializza A e lascia B in uno stato indeterminato. Perché C++ dovrebbe scegliere un comportamento non definito semplicemente chiamando il costruttore predefinito di B()? In gran parte sconfigge lo scopo della caratteristica dei costruttori ereditari.

Edit:

Forse questo dovrebbe essere consentito:

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

Answer 1

using A::A; dichiara implicitamente B(int) nella classe derivata. È così.

Il resto del programma non dovrebbe funzionare come previsto. Perché stai invocando B(int) con B(5) e questo lascia m_y non inizializzato.

Vedere questo esempio dal sito di Bjarne Stroustrup:

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

Un altro esempio dallo stesso 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 
    }