Double inheritance type deduction

I have the following template class:

template<class T>
class Foo {
  public:
    void Bar(T* t) { member = t; }
  private:
    T* member;
};

This is used (twice) as a base class for a different class:

class AwesomeClass : public Foo<ISomeInterface>, public Foo<IOtherInterface> {};

Which is then called something like this:

class Caller {
  void Init(ISomeInterface * i) {
    AwesomeClass a;
    a.Bar(i);
   }
}

However this does not compile, stating that the call to Bar is ambiguous. Therefore I need to use a.Foo<ISomeInterface>::Bar(i), because apparently the compiler cannot determine which Bar to call (even thought it is given an ISomeInterface object). Any ways around this?

Also I am wondering if inheritance is the 'correct' approach here or if composition would be a better option.

You can introduce Bars into AwesomeClass, then both can be found in scope of AwesomeClass then overload resolution kicks in. E.g.

class AwesomeClass : public Foo<ISomeInterface>, public Foo<IOtherInterface> {
public:
    using Foo<ISomeInterface>::Bar;
    using Foo<IOtherInterface>::Bar;
};

LIVE

You want friend functions and ADL. This way you don't need to individually using every such method from every base.

template <typename T>
class Foo
{
    T *member = nullptr;
    
  public:
    friend void Bar(Foo &self, T *t)
    {
        self.member = t;
    }
};

void Init(ISomeInterface * i)
{
    AwesomeClass a;
    Bar(a, i);
}