C++11 constructor inheritance through variadic templates

Question

I recently came across an instance in which I realized that several classes I had written shared a lot of functionality. I realized I could generalize these classes into a common base with some template parameters. The problem is that these classes have about 20 different overloaded constructors, where most of the classes functionality is implemented. Using I came up with the solution illustrated here:

template <typename T>
class Base {

  protected:

    T member_;

  public:

    Base(int a) { /* ... */ }

    Base(double a) { /* ... */ }

    Base(char a) { /* ... */ }

    Base(int a, double b, char c) { /* ... */ }

    // etc...

};

class Derived1 : public Base<int> {

  public:

    template <typename... Args>
    Derived1(Args... args) : Base(args...) { }

    // other constructors specific to Derived1

};

class Derived2 : public Base<char> {

  public:

    template <typename... Args>
    Derived2(Args... args) : Base(args...) { }

    // other constructors specific to Derived2

};

I have several questions here:

Is there any runtime performance hit associated with this? (After looking around, it seems like I should be using rvalue references and std::forward in the derived classes, right?)
From a code maintainability point of view, is this a good idea?
What are some pitfalls of this approach? (e.g. similar examples elsewhere seem to be using the explicit keyword. Why?)
Is there a better, more standard, more safe, or more readable way to do this?

score 4 · Answer 1 · edited May 23 '17 at 11:51

4

In C++11 , constructors can be inherited.

See https://stackoverflow.com/a/434784/232574

edited May 23 '17 at 11:51

Community

1
1

answered Jan 10 '14 at 18:34

Nick Strupat

4,928
4
44
56

Is there a runtime penalty associated with inherited constructors, since you're jumping around more (compared to replicating the constructors, not compared with my version)? What about compiler support for this feature? – Daisy Sophia Hollman Jan 10 '14 at 18:41
No runtime penalty. It's just shorthand for the compiler to essentially forward the base constructors to the derived. Check out http://stackoverflow.com/questions/9979194/what-is-constructor-inheritance for more info – Nick Strupat Jan 10 '14 at 18:44
Thanks. Both answers are good; I accepted the other one for now, but I think future viewers of this question will benefit from having both answers here. – Daisy Sophia Hollman Jan 10 '14 at 18:51

score 3 · Accepted Answer · answered Jan 10 '14 at 18:46

Yes, you should be using perfect forwarding. If the constructors are declared inline, there will be zero performance impact.
It is a "scary-looking template," but easily recognized by someone who knows anything about templates. Depends on your maintainers, I guess?
You need to beware of intercepting calls intended for the derived class's copy and move constructor, since your variadic perfect forwarding signature matches everything. Properly constraining with enable_if usually requires more code than the forwarding constructor itself.
Inheriting constructors is the "better" way to do this. The feature is specified to avoid capturing signatures that should go to the derived class constructors. Compiler support may be iffy: it's not the easiest feature to implement, or the most in-demand, so implementors put it off for quite a while.

C++11 constructor inheritance through variadic templates

2 Answers2