Mixing Templates, Multiple Inheritance, and non-Default Constructor

Question

I have a base class that implements some functionality, and a template class that virtually extends it. The base class has a non-default constructor since it requires some configuration data. The template has a default constructor.

class Base
{
public:
    explicit Base(int data): m_data{data} {}
    int boilerplate(int x) const { return x + m_data; }
protected:
    int m_data;
};

template<typename T>
class Test: public virtual Base
{
public:
    virtual int foo(T x) const { return x + m_data; } // works by default for integers for convenience
};

I am trying to create a class that inherits from multiple specializations of the template, which can pass the same data to the single virtual base class.

class MultiTest : public Test<float>, public Test<double>
{
public:
    int foo(float x) const override { return x * static_cast<float>(boilerplate(3)); }
    int foo(double x) const override { return x / static_cast<double>(boilerplate(10)); }
};

If I instantiate the class with an integer argument, I get an error:

int main() { MultiTest x{32}; }

$ g++ test.cpp
test.cpp: In function ‘int main()’:
test.cpp:24:26: error: no matching function for call to ‘MultiTest::MultiTest(<brace-enclosed initializer list>)’
   24 | int main() { MultiTest x{32}; }
      |                            ^
test.cpp:17:7: note: candidate: ‘MultiTest::MultiTest(const MultiTest&)’
   17 | class MultiTest : public Test<float>, public Test<double>
      |       ^~~~~~~~~
test.cpp:17:7: note:   no known conversion for argument 1 from ‘int’ to ‘const MultiTest&’
test.cpp:17:7: note: candidate: ‘MultiTest::MultiTest(MultiTest&&)’
test.cpp:17:7: note:   no known conversion for argument 1 from ‘int’ to ‘MultiTest&&’

I can't do int main() { MultiTest x; } with no arguments either of course, since the Base` class does not have a default constructor:

$ g++ test.cpp 
test.cpp: In function ‘int main()’:
test.cpp:24:24: error: use of deleted function ‘MultiTest::MultiTest()’
   24 | int main() { MultiTest x; }
      |                        ^
test.cpp:17:7: note: ‘MultiTest::MultiTest()’ is implicitly deleted because the default definition would be ill-formed:
   17 | class MultiTest : public Test<float>, public Test<double>
      |       ^~~~~~~~~
test.cpp:17:7: error: use of deleted function ‘Test<float>::Test()’
test.cpp:11:7: note: ‘Test<float>::Test()’ is implicitly deleted because the default definition would be ill-formed:
   11 | class Test: public virtual Base
      |       ^~~~
test.cpp:11:7: error: no matching function for call to ‘Base::Base()’
test.cpp:4:14: note: candidate: ‘Base::Base(int)’
    4 |     explicit Base(int data): m_data{data} {}
      |              ^~~~
test.cpp:4:14: note:   candidate expects 1 argument, 0 provided
test.cpp:1:7: note: candidate: ‘constexpr Base::Base(const Base&)’
    1 | class Base
      |       ^~~~
test.cpp:1:7: note:   candidate expects 1 argument, 0 provided
test.cpp:1:7: note: candidate: ‘constexpr Base::Base(Base&&)’
test.cpp:1:7: note:   candidate expects 1 argument, 0 provided
test.cpp:17:7: error: use of deleted function ‘Test<double>::Test()’
   17 | class MultiTest : public Test<float>, public Test<double>
      |       ^~~~~~~~~
test.cpp:11:7: note: ‘Test<double>::Test()’ is implicitly deleted because the default definition would be ill-formed:
   11 | class Test: public virtual Base
      |       ^~~~
test.cpp:11:7: error: no matching function for call to ‘Base::Base()’
test.cpp:4:14: note: candidate: ‘Base::Base(int)’
    4 |     explicit Base(int data): m_data{data} {}
      |              ^~~~
test.cpp:4:14: note:   candidate expects 1 argument, 0 provided
test.cpp:1:7: note: candidate: ‘constexpr Base::Base(const Base&)’
    1 | class Base
      |       ^~~~
test.cpp:1:7: note:   candidate expects 1 argument, 0 provided
test.cpp:1:7: note: candidate: ‘constexpr Base::Base(Base&&)’
test.cpp:1:7: note:   candidate expects 1 argument, 0 provided
test.cpp:17:7: error: no matching function for call to ‘Base::Base()’
   17 | class MultiTest : public Test<float>, public Test<double>
      |       ^~~~~~~~~
test.cpp:4:14: note: candidate: ‘Base::Base(int)’
    4 |     explicit Base(int data): m_data{data} {}
      |              ^~~~
test.cpp:4:14: note:   candidate expects 1 argument, 0 provided
test.cpp:1:7: note: candidate: ‘constexpr Base::Base(const Base&)’
    1 | class Base
      |       ^~~~
test.cpp:1:7: note:   candidate expects 1 argument, 0 provided
test.cpp:1:7: note: candidate: ‘constexpr Base::Base(Base&&)’
test.cpp:1:7: note:   candidate expects 1 argument, 0 provided

If I try to add a call to the Base constructor in MultiTest, e.g. with explicit MultiTest(int data): Base{data} {} similar stuff happens:

$ g++ test.cpp 
test.cpp: In constructor ‘MultiTest::MultiTest(int)’:
test.cpp:20:44: error: use of deleted function ‘Test<float>::Test()’
   20 |     explicit MultiTest(int data): Base{data} {}
      |                                            ^
test.cpp:11:7: note: ‘Test<float>::Test()’ is implicitly deleted because the default definition would be ill-formed:
   11 | class Test: public virtual Base
      |       ^~~~
test.cpp:11:7: error: no matching function for call to ‘Base::Base()’
test.cpp:4:14: note: candidate: ‘Base::Base(int)’
    4 |     explicit Base(int data): m_data{data} {}
      |              ^~~~
test.cpp:4:14: note:   candidate expects 1 argument, 0 provided
test.cpp:1:7: note: candidate: ‘constexpr Base::Base(const Base&)’
    1 | class Base
      |       ^~~~
test.cpp:1:7: note:   candidate expects 1 argument, 0 provided
test.cpp:1:7: note: candidate: ‘constexpr Base::Base(Base&&)’
test.cpp:1:7: note:   candidate expects 1 argument, 0 provided
test.cpp:20:44: error: use of deleted function ‘Test<double>::Test()’
   20 |     explicit MultiTest(int data): Base{data} {}
      |                                            ^
test.cpp:11:7: note: ‘Test<double>::Test()’ is implicitly deleted because the default definition would be ill-formed:
   11 | class Test: public virtual Base
      |       ^~~~
test.cpp:11:7: error: no matching function for call to ‘Base::Base()’
test.cpp:4:14: note: candidate: ‘Base::Base(int)’
    4 |     explicit Base(int data): m_data{data} {}
      |              ^~~~
test.cpp:4:14: note:   candidate expects 1 argument, 0 provided
test.cpp:1:7: note: candidate: ‘constexpr Base::Base(const Base&)’
    1 | class Base
      |       ^~~~
test.cpp:1:7: note:   candidate expects 1 argument, 0 provided
test.cpp:1:7: note: candidate: ‘constexpr Base::Base(Base&&)’
test.cpp:1:7: note:   candidate expects 1 argument, 0 provided

I've also tried explicit MultiTest(int data): Test<float>{data}, Test<double>{data} {}:

$ g++ test.cpp 
test.cpp: In constructor ‘MultiTest::MultiTest(int)’:
test.cpp:20:71: error: no matching function for call to ‘Base::Base()’
   20 |     explicit MultiTest(int data): Test<float>{data}, Test<double>{data} {}
      |                                                                       ^
test.cpp:4:14: note: candidate: ‘Base::Base(int)’
    4 |     explicit Base(int data): m_data{data} {}
      |              ^~~~
test.cpp:4:14: note:   candidate expects 1 argument, 0 provided
test.cpp:1:7: note: candidate: ‘constexpr Base::Base(const Base&)’
    1 | class Base
      |       ^~~~
test.cpp:1:7: note:   candidate expects 1 argument, 0 provided
test.cpp:1:7: note: candidate: ‘constexpr Base::Base(Base&&)’
test.cpp:1:7: note:   candidate expects 1 argument, 0 provided
test.cpp:20:71: error: no matching function for call to ‘Test<float>::Test(<brace-enclosed initializer list>)’
   20 |     explicit MultiTest(int data): Test<float>{data}, Test<double>{data} {}
      |                                                                       ^
test.cpp:11:7: note: candidate: ‘Test<float>::Test(const Test<float>&)’
   11 | class Test: public virtual Base
      |       ^~~~
test.cpp:11:7: note:   no known conversion for argument 1 from ‘int’ to ‘const Test<float>&’
test.cpp:11:7: note: candidate: ‘Test<float>::Test(Test<float>&&)’
test.cpp:11:7: note:   no known conversion for argument 1 from ‘int’ to ‘Test<float>&&’
test.cpp:20:71: error: no matching function for call to ‘Test<double>::Test(<brace-enclosed initializer list>)’
   20 |     explicit MultiTest(int data): Test<float>{data}, Test<double>{data} {}
      |                                                                       ^
test.cpp:11:7: note: candidate: ‘Test<double>::Test(const Test<double>&)’
   11 | class Test: public virtual Base
      |       ^~~~
test.cpp:11:7: note:   no known conversion for argument 1 from ‘int’ to ‘const Test<double>&’
test.cpp:11:7: note: candidate: ‘Test<double>::Test(Test<double>&&)’
test.cpp:11:7: note:   no known conversion for argument 1 from ‘int’ to ‘Test<double>&&’

And gotten similar results for explicit MultiTest(int data): Test<float>{data}, Test<double>{data}, Base{data} {}:

$ g++ test.cpp 
test.cpp: In constructor ‘MultiTest::MultiTest(int)’:
test.cpp:20:83: error: no matching function for call to ‘Test<float>::Test(<brace-enclosed initializer list>)’
   20 |     explicit MultiTest(int data): Test<float>{data}, Test<double>{data}, Base{data} {}
      |                                                                                   ^
test.cpp:11:7: note: candidate: ‘Test<float>::Test(const Test<float>&)’
   11 | class Test: public virtual Base
      |       ^~~~
test.cpp:11:7: note:   no known conversion for argument 1 from ‘int’ to ‘const Test<float>&’
test.cpp:11:7: note: candidate: ‘Test<float>::Test(Test<float>&&)’
test.cpp:11:7: note:   no known conversion for argument 1 from ‘int’ to ‘Test<float>&&’
test.cpp:20:83: error: no matching function for call to ‘Test<double>::Test(<brace-enclosed initializer list>)’
   20 |     explicit MultiTest(int data): Test<float>{data}, Test<double>{data}, Base{data} {}
      |                                                                                   ^
test.cpp:11:7: note: candidate: ‘Test<double>::Test(const Test<double>&)’
   11 | class Test: public virtual Base
      |       ^~~~
test.cpp:11:7: note:   no known conversion for argument 1 from ‘int’ to ‘const Test<double>&’
test.cpp:11:7: note: candidate: ‘Test<double>::Test(Test<double>&&)’
test.cpp:11:7: note:   no known conversion for argument 1 from ‘int’ to ‘Test<double>&&’

What do I need to do to MultiTest or in main to make this work? Also, why?

Answer 1

You need to supply some additional constructors (if you compile with clang, the compiler errors say why):

template<typename T>
class Test: public virtual Base
{
public:
    explicit Test (int data) : Base (data) { } // <==

    virtual int foo(T x) const { return x + m_data; } // works by default for integers for convenience
};

and:

class MultiTest : public Test<float>, public Test<double>
{
public:
    explicit MultiTest (int data) : Base (data), Test <float> (data), Test <double> (data) { } // <==

    int foo(float x) const override { return x * static_cast<float>(boilerplate(3)); }
    int foo(double x) const override { return x / static_cast<double>(boilerplate(10)); }
};

There may be a shorter solution. Can't say I like the whole idea much, btw.

Answer 2

Since Base does not have a default constructor, Test can't either. One way to solve this is to give Base a protected empty constructor:

protected:
    Base(int data) m_data{} {}

Now, the empty constructor of Test won't be deleted and we can make a constructor that only needs to initialize Base: MultiTest(int data): Base{data} {}.

Answer 3

Your Test template is meant to be combined with several specializations as your MultiTest implies. However, in that combination, all the Test specialization must share the same Base (hence the virtual inheritance). Another way to look at this would be to avoid the virtual inheritance and do something like this:

class Base
{
public:
    explicit Base(int data): m_data{data} {}
    int boilerplate(int x) const { return x + m_data; }
protected:
    int m_data;
};

template< typename T >
class Test // <- no inheritance
{
public:
    int fooImpl(T x) { return x; }
};

template< typename... Ts >
class MultiTest : public Base, Test< Ts >...
{
public:
    MultiTest(int data) : Base(data), Test< Ts >()... {}
    // You can prettify this for error handling using concepts/static_asserts...
    template< typename T >
    int foo(T x) { return Test< T >::fooImpl(x) + m_data; }
};

Usage stays the same as in your sample:

MultiTest< int, double > m{ 1 };
m.foo(12); // Will call Test< int >::fooImpl

With one caveat, since we have a template, the following call would yield a compiler error:

m.foo(12u); // Will call Test< unsigned>::fooImpl but MultiTest< int, double > does not inherit from Test< unsigned >

You can safeguard against this kind of behavior with more advanced metaprogramming bits.

Full example: https://coliru.stacked-crooked.com/a/4092d65e35571b41