避免打开模板参数

简化后我有以下类层次结构：

class BaseVec {
  public:
    BaseVec() {};
    virtual ~BaseVec() {};

    virtual double get_double(int i) const = 0;
};

template<typename T>
class Vec : public BaseVec {
  public:
    Vec() { ... };
    ~Vec() { ... };

    T get(int i) const { ... };

    double get_double(int i) const {
      return get(i);
    };
};

在我的项目中，我反复得到以下形式的代码：

template<typename T>
double foo_template(void* p) {
  Vec<T>* v = reinterpret_cast<Vec<T>*>(p);
  // use v which involves calling get
  return result;
}

double foo(void* p, int type) {
  if (type == 0) {
    return foo_template<double>(p);
  } else if (type == 1) {
    return foo_template<int>(p);
  } else if (...) {
    // etc.
  } else {
    //unsupported type
  }
}

（我可以使用开关并使用枚举，或者首先进行强制转换p to BaseVec然后做dynamic_casts，但逻辑保持不变）

这并不理想维护。例如，当我添加一个想要支持的附加类时，我必须向每个 if-else-if 块添加一个子句。

简化此操作的一种可能方法是强制转换p to BaseVec*并使用get_double方法。但是，由于经常调用此方法，因此会导致性能不佳。此外，这并不总是可能的：有时我想打电话给get方法作为返回的类型很重要。

我尝试了访问者模式，尽管这有一些优点，但这仍然意味着我必须为每个可能的模板参数编写单独的代码。

有什么方法可以让这段代码更容易维护吗？

PS：我对发生的事情没有（太多）控制权foo. foo由外部程序（确切地说是 R）调用。因此，我只能将通用指针、int、double 和字符向量传递给foo.

PPS：也欢迎提出更好的标题建议。

首先，不要使用reinterpret_cast在与多态类的指针之间进行转换时。您可以编写一个简单的指针包装器，它允许您使用安全转换运算符static_cast:

template <class Type>
class PointerWrapper
{
public:

    PointerWrapper(Type* object);
    PointerWrapper& operator=(Type* object);
    Type* operator->();

protected:

    Type* object;

};

template <class Type>
PointerWrapper<Type>::PointerWrapper(Type* object) :
    object(object)
{
}

template <class Type>
PointerWrapper<Type>& PointerWrapper<Type>::operator=(Type* object)
{
    this->object = object;
}

template <class Type>
Type* PointerWrapper<Type>::operator->()
{
    return object;
}

现在你可以写：

typedef PointerWrapper<BaseVec> BaseVecPointer;

template<typename T>
double foo(void* p) {
    BaseVecPointer* vp = static_cast<BaseVecPointer*>(p);
    // ...
    // ... = (*vp)->get_double(...);
    // ...
    return result;
}

在此代码中使用了多态性功能，即函数get_double被调用而不是调用get.

但如果你想打电话get, not get_double，即您想根据运行时变量的值调用具有不同模板参数的模板函数，可以使用以下方法：

enum FooTypes
{
    NoFooType = -1,
    DoubleFooType = 0,
    IntegerFooType = 1,
    // ...
    FooTypesCount
};

template<FooTypes fooType>
struct ChooseType
{
    static
    const FooTypes value = NoFooType;

    typedef void Type;
};

template<>
struct ChooseType<DoubleFooType>
{
    static
    const FooTypes value = DoubleFooType;

    typedef double Type;
};

template<>
struct ChooseType<IntegerFooType>
{
    static
    const FooTypes value = IntegerFooType;

    typedef int Type;
};

在这里您应该编写类模板的专业化ChooseType对于所有可能的值type多变的。 下面的代码描述了该功能ChooseFoo选择什么专业foo_template函数模板应该被调用：

typedef double (*FooFunction)(void*);

template<FooTypes fooType>
FooFunction ChooseFooImpl(int type)
{
    if (type == fooType)
    {
        if (ChooseType<fooType>::value != NoFooType)
        {
            return foo_template<typename ChooseType<fooType>::Type>;
        }
        else
        {
            return NULL;
        }
    }
    else
    {
        return ChooseFooImpl<(FooTypes)(fooType - 1)>(type);
    }
}

template<>
FooFunction ChooseFooImpl<NoFooType>(int type)
{
    return NULL;
}

FooFunction ChooseFoo(int type)
{
    return ChooseFooImpl<FooTypesCount>(type);
}

这是foo功能实现：

double foo(void* p, int type)
{
    FooFunction fooFunction = ChooseFoo(type);

    if (fooFunction != NULL)
    {
        return fooFunction(p);
    }
    else
    {
        //unsupported type
        // ...
    }
}