Question

I have the following scenario :-

template <typename T>
class Base {
  public:
    virtual void someFunc() {}
};

class Derived : public Base<int>,
                public Base<float> {
  public:
    virtual void someFunc() { 
      // do something different if Base<int> than if Base<float>
    }
};

Derived *d = new D();
Base<int>* b1 = (Base<int>*) d;
Base<float>* b2 = (Base<float>*) d;

b1->someFunc();
b2->someFunc();

I want to be able to distinguish between these two function calls. Or in other words, over-ride the two base functions with different function bodies.

Answer 1

You could use a shim (this works for any instance of name collisions between base classes, whether template-related or not):

template <typename T>
class Base
{
  public:
    virtual void someFunc() {}
};

class IntShim : public Base<int>
{
  protected:
    virtual void someFuncViaInt() = 0;
  public:
    virtual void someFunc() { return someFuncViaInt(); }
};

class FloatShim : public Base<float>
{
  protected:
    virtual void someFuncViaFloat() = 0;
  public:
    virtual void someFunc() { return someFuncViaFloat(); }
};

class Derived : public IntShim, public FloatShim
{
  protected:
    virtual void someFuncViaInt()
    { 
      // do something for Base<int>
    }
    virtual void someFuncViaFloat()
    { 
      // do something for Base<float>
    }
};

Derived *d = new D();
Base<int>* b1 = (Base<int>*) d;
Base<float>* b2 = (Base<float>*) d;

b1->someFunc();
b2->someFunc();