How to call inherited class's functions in templated class

Question

If a class inherits multiple classes with the same function, how does it call each inherited class's function without manually specific each class?

Example code as below:

#include <cstdio>

class Interface1
{
  public:
    virtual ~Interface1() = default;
    void foo()
    {
        printf("%s\n", __PRETTY_FUNCTION__);
    }
};

class Interface2
{
  public:
    virtual ~Interface2() = default;
    void foo()
    {
        printf("%s\n", __PRETTY_FUNCTION__);
    }
};

class ObjectWithoutTemplate : public Interface1, Interface2
{
  public:
    void foo()
    {
        // How do I write the code to call each InterfaceX's foo() here
        // without manually specify each class?
        Interface1::foo();
        Interface2::foo();
        // The desired code looke like
        // for each interface in Interfaces {
        //     interface::foo()
        // }
    }
};

template <class... Interfaces>
class ObjectWithTemplate : Interfaces...
{
  public:
    void foo()
    {
        // It does not compile if the template does not inherit Interface[1|2]
        Interface1::foo();
        Interface2::foo();
        // The desired code looke like
        // for each interface in Interfaces {
        //     interface::foo()
        // }
    }
};
int main()
{
    ObjectWithoutTemplate objWithout;
    ObjectWithTemplate<Interface1, Interface2> objWith;
    objWithout.foo();
    objWith.foo();
    return 0;
}

For ObjectWithoutTemplate, I could call interfaces' foo() by manually specifying the interface:

    Interface1::foo();
    Interface2::foo();

But for ObjectWithTemplate's foo(), how do I write the code to call each inherited interfaces' foo(), considering there will be Interface3, Interface4 as well.

check out this https://stackoverflow.com/questions/3360892/multiple-inheritance-template-class — The Philomath, Sep 23 '19 at 03:46
@ThePhilomath That solves a different problem (calling one of the base class's functions that only differ by parameters). — 1201ProgramAlarm, Sep 23 '19 at 04:15
You can't. You have to specify the base class in some way. An alternative is `Interface1* i1 = this; i1->foo();` — j6t, Sep 23 '19 at 05:31

score 4 · Answer 1 · answered Sep 23 '19 at 06:49

Assuming you don't want any of the bases to be repeated (and none of the bases inherit from each other) you can do this;

template <class FirstInterface, class... Interfaces>
class ObjectWithTemplate : public FirstInterface, public ObjectWithTemplate<Interfaces...>
{
   public:
      void foo()
      {
          FirstInterface::foo();
          ObjectWithTemplate<Interfaces...>::foo();
      };
};

// partial specialisation
template<class LastInterface> 
class ObjectWithTemplate<LastInterface> : public LastInterface
{
    public:
       void foo()
       {
           LastInterface::foo();
       };
};

An object of type

ObjectWithTemplate<Interface1, Interface2> object;

actually has Interface1 and ObjectWithTemplate<Interface2> as base classes. ObjectWithTemplate<Interface2>, in turn, has Interface2 as a base class.

If you repeat bases, or use two bases that share another base such as

ObjectWithTemplate<Interface1, Interface1> object;

ObjectWithTemplate<Interface1, SomethingDerivedFromInterface1> object2;

then the code will not compile due to ambiguity.

Yes, it works and compares to my own answer, it does not require extra space of `std::tuple`! Could you kindly check my answer (which is less code) and perhaps improves it to make it not using `std::tuple`? — Mine, Sep 23 '19 at 07:04

score 2 · Answer 2 · answered Sep 23 '19 at 07:00

Inspired by Generating one class member per variadic template argument, using std::tuple<> makes it work.

It's not perfect because it increases the binary size, but it works cleanly.

template <class... Interfaces>
class ObjectWithTemplate : public Interfaces...
{
  public:
    std::tuple<Interfaces...> interfaces;

    void foo()
    {
        // The size becomes 8 * num-of-inherited-classes
        printf("sizeof(interfaces)=%zu\n", sizeof(interfaces));
        std::apply([&](auto&&... args) {
            (static_cast<decltype(args)>(*this).foo(), ...);
            },
            interfaces);
    }
};

As you already use folding expression, you might use directly with bases, see my answer. — Jarod42, Sep 23 '19 at 08:09

score 1 · Accepted Answer · answered Sep 23 '19 at 08:06

1

Folding expressions from C++17 helps here:

template <class... Interfaces>
class ObjectWithTemplate : public Interfaces...
{
  public:
    void foo()
    {
        (Interfaces::foo(), ...);
    }
};

For C++11/C++14 version, it can also be done but is more verbose.

answered Sep 23 '19 at 08:06

Jarod42

203,559
14
181
302

Wow, this is great! – Mine Sep 23 '19 at 08:19

How to call inherited class's functions in templated class

3 Answers3