稍微派生一个类而不会失去对其构造函数的访问权限

Question

Suppose I have a large class with a lot of functionality and a relatively large interface. Particularly, there are many constructors for convenient instantiation. From this class, several classes could be derived with some slightly extended interface and/or customized virtual functions.

The problem: I will have to copy all the constructors into the derived classes which would mean a lot of code duplication. Even worse: The constructors slightly depend on the derived class, which I would solve by a virtual call, but this does not work in a constructor.

What's a good approach to tackle this problem?

EDIT: I know that I can delegate constructors Derived(arguments) : Base(arguments) {} but I'd still need to copy parts of the constructor which I try to avoid.

Answer 1

Use using declarations to make the constructors of the base class aviable on the derived one:

class Base
{
public:
    Base( int , int , int );
};

class Derived : public Base
{
public:
    using Base::Base; //Automatically adds all the base constructors
};

EDIT: Here is a running example.

Answer 2

I do not know exactly if it works for your problem, but you might think about making some kind of 'initialization' object where you handle the properties of the object you want to create. This will have a lot of constructors.

Then you pass this object to the 'real' class where the properties are used to create the actual object.

Answer 3

If C++ 11 extensions can be used, then the other answer that recommends using is a perfect answer.

If not, then the only way is:

class x:  public y
{
    // modified constructors:

    x (int a) : y (1, 2, a + 3) { your code if any; }
    x (int a, int b) : y (b, a) { your code if any; }

    // delegated constructors: alas, repeated for all constructors of y

    x (int c, float d) : y (c, d) { /* no code*/ }
    x (float e, int f) : y (e, f) { /* no code*/ }
}

The latter part is not really code duplication because you only duplicate interface but no code.

Answer 4

Do the initializations applicable in respective classes. For example, say A is superclass and B is a subclass, so you may use,

B::B(...arguments...): A(...arguments that you would like to pass to superclass constructor)
{
}