c++ - 有没有办法区分来​​自两个模板化基类的这些函数调用？

Question

我有以下情况： -

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();

我希望能够区分这两个函数调用。或者换句话说，用不同的函数体覆盖两个基本函数。

Answer 1

您可以使用 shim（这适用于基类之间的任何名称冲突实例，无论是否与模板相关）：

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();

Answer 2

您可以实现这一点的一种方法是将虚拟参数添加到someFuncon Base：

virtual void someFunc(T *dummy = nullptr);

在派生类中，您的覆盖是然后

virtual void someFunc(int *);
virtual void someFunc(float *);

而不是T *你可以创建一个空类型

template<typename T> struct dispatch {};
...
virtual void someFunc(dispatch<T> = dispatch<T>());
...
virtual void someFunc(dispatch<int>);
virtual void someFunc(dispatch<float>);

这消除了传递 nullptr 的（最小）开销，并有助于阐明参数的用途。

Answer 3

您不需要为此使用虚拟函数和派生类。您可以将 Base 类中的函数专门用于已知类型。

你可以做某事。像这样：

template <typename T>
class Base {
  public:
    void someFunc()
    {
        // default implementation for any type
    }
};

// specialization for int
template<> void Base<int>::someFunc()
{
}

// specialization for float
template<> void Base<float>::someFunc()
{
}

int main(int argc, char** argv)
{
    Base<int>* b1 = new Base<int>();
    Base<float>* b2 = new Base<float>();

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