How can I fake constructor inheritance in C++03? - c++

Question

As far as I know, you cannot inherit constructors in C++. But there are situations, where it might be required that it looks like you can instantiate inherited classes the same way you instantiate their base:
struct Base {
int i;
int const j;
Base(int i, int j) : i(i), j(j) {}
};
// option 1)
struct Derived1 : Base {
Derived1(int i, int j) : Base(i,j) {}
};
Base* baseFactory() {
return new Derived1(42,47);
}
// option 2)
struct Derived2 : Base {
};
Base* baseFactory() {
Base* b = new Derived2();
b->i = 42;
b->j = 47; // broken!
// alternative could be to implement Base::operator=
return b;
}
Note that the derived classes could be default constructed if it weren't for their base class(es).
Option 1 is what is usually done, I think, but you are typing code without expressing anything new. Option 2 breaks const correctness (and prevents you from using references as members) because everything must be assignable.
Is there a nice way around this?
Edit: C++11 is great, but unfortunately I need a C++03 solution.

Answer 1

Option 1 is the idiomatic way in C++03, it does require more typing, but that is how the language is. Option 2 is not even close to equivalent, you would not be able to initialize Derived2 as Base does not have a default constructor, and the definition of the implicitly declared default constructor for Derived2 needs it.
But beyond the technical difficulty in the language you are trading construction for two-phase construction which is never a good idea, and at the same time forcing your use of Derived2 to dynamically allocated objects.

Answer 2

There is an alternative approach:
// option 3)
struct Derived3 : Base {
Derived3(const Base &b) : Base(b) {}
};
Base* baseFactory3() {
return new Derived3(Base(42,47));
}
This may not be a good idea if constructing a full Base object is expensive or requires external resources. In that case you could create a light-weight object that carries constructor arguments for Base, so that instead of multiple Base constructors you have multiple BaseArguments constructors, and one Base constructor that takes in BaseArguments. However I don't think many people would consider that good style in most circumstances.

Answer 3

C++11 supports inherited constructors.
http://en.wikipedia.org/wiki/C%2B%2B11
However not all compilers that supports now a subset of C++11 supports all functionalities.
Microsoft visual C++ 2010 supports several new C++0x features but not inherited constructors, here is a list: http://blogs.msdn.com/b/vcblog/archive/2010/04/06/c-0x-core-language-features-in-vc10-the-table.aspx
GCC supports more new features but not the inherited constructors. See http://gcc.gnu.org/projects/cxx0x.html
To enable GCC to compile with C++0x features you need to add -std=c++0x or -std=gnu++0x compilation parameter.
Visual C++ 2010 have these enabled by default.
You just need to wait :)
There are not clean solutions for previous version of the standard, for this reason it was introduced in C++11, because it was not possible to do with previous versions.
So, the only thing you can do, is to copy your constructors and call base constructor.

Answer 4

Here' a variation on the Builder Pattern that I always thought it could be useful, but I never actually got a chance to use it; I guess you could call it the Constructor Pattern. :P
It also offers some other advantages, like not having to specify arguments in a certain order: you only specify what you are interested in and in whatever order you want.
I still think this is justified only if your class has lots of constructors with different parameters. Otherwise, it's just an annoyance.
class Person
{
public:
class Constructor;
};
class Person::Constructor
{
public:
Constructor& name(const std::string&);
Constructor& age(int);
Person* make();
};
Person* pers = Person::Constructor()
.name("Bob Marley").make();
class Employee : public Person
{
public:
class Constructor;
};
class Employee::Constructor : public Person::Constructor
{
public:
Constructor& salary(double);
Employee* make();
};
Employee* emp = Employee::Constructor()
.name("Emilly Smith").age(23).make();
But again, this is justifiable only if your class has lots of constructors with lots of parameters and you want to avoid having to write multiple overloads to those; otherwise, this just adds too much complexity without any real benefit.
I mentioned I don't like han's proposed solution. This is because (1) you are moving the need to (re)declare a number of constructors in the child class to the need to place the same number of functions inside a factory class; (2) it is hacky and the intent is not explicit; and (3) you could view this as a violation of dependency injection.