¿Qué tan útil sería Heredar Constructores en C++?

Un par de inconvenientes para la solución propuesta:

• Es más largo
• Tiene más fichas
• Utiliza nuevas características del lenguaje complicado

En general, la complejidad cognitiva de la solución es muy, muy mala. Mucho peor que, por ejemplo, las funciones miembro especiales predeterminadas, para las que se agregó una sintaxis simple.

Motivación en el mundo real para la herencia de constructores: Mix-ins AOP implementados usando herencia repetida en lugar de múltiple herencia.

Además de lo que otros han dicho, considere este ejemplo artificial:

#include <iostream>

class MyString
{
public:
    MyString( char const* ) {}
    static char const* name() { return "MyString"; }
};

class MyNumber
{
public:
    MyNumber( double ) {}
    static char const* name() { return "MyNumber"; }
};

class MyStringX: public MyString
{
public:
    //MyStringX( char const* s ): MyString( s ) {}              // OK
    template< class ... Args > 
        MyStringX( Args&& ... args ): MyString( args... ) {}    // !Nope.
    static char const* name() { return "MyStringX"; }
};

class MyNumberX: public MyNumber
{
public:
    //MyNumberX( double v ): MyNumber( v ) {}                   // OK
    template< class ... Args > 
        MyNumberX( Args&& ... args ): MyNumber( args... ) {}    // !Nope.
    static char const* name() { return "MyNumberX"; }
};

typedef char    YesType;
struct NoType { char x[2]; };
template< int size, class A, class B >
struct Choose_{ typedef A T; };
template< class A, class B >
struct Choose_< sizeof( NoType ), A, B > { typedef B T; };

template< class Type >
class MyWrapper
{
private:
    static Type const& dummy();
    static YesType accept( MyStringX );
    static NoType accept( MyNumberX );
public:
    typedef typename
        Choose_< sizeof( accept( dummy() ) ), MyStringX, MyNumberX >::T T;
};

int main()
{
    using namespace std;
    cout << MyWrapper< int >::T::name() << endl;
    cout << MyWrapper< char const* >::T::name() << endl;
}

Al menos con MinGW g++ 4.4.1, la compilación falla debido al reenvío del constructor C++0x.

Se compila bien con el reenvío "manual" (constructores comentados), y presumiblemente/posiblemente también con constructores heredados?

Salud y hth.

Veo un problema cuando la nueva clase tiene variables miembro que necesitan ser inicializadas en el constructor. Este será el caso común, ya que generalmente una clase derivada agregará algún tipo de estado a la clase base.

Es decir:

struct B 
{ 
   B(int); 
}; 

struct D : B 
{ 
   D(int a, int b) : B(a), m(b) {}
   int m;
}; 

Para aquellos que tratan de resolverlo: ¿cómo distinguir entre :B(a), m(b) y :B(b), m(a) ? ¿Cómo se maneja la herencia múltiple? ¿herencia virtual?

Si solo se resuelve el caso más simple, tendrá una utilidad muy limitada en la práctica. No me pregunto si los proveedores del compilador aún no han implementado la propuesta.

Filosóficamente, estoy en contra de heredar constructores. Si estás definiendo una nueva clase, estás definiendo cómo se va a crear. Si la mayor parte de esa construcción puede tener lugar en la clase base, entonces es totalmente razonable que reenvíe ese trabajo al constructor de la clase base en la lista de inicialización. Pero todavía tienes que hacerlo explícitamente.