C++ - 通过模板仿函数专门化成员函数模板不编译

Question

我希望创建一个可以在 float 和 double 组之间进行多态转换的类。也就是说，相关实例(由 <double> 或 <float> 参数化)和通过 float* 的决定或 double*是在运行时决定的，而不是静态的。

作为 proposed answer另一个问题，但根据 this answer 修改(因为我知道不可能在一个类中完全特化一个成员函数模板)，一个纯虚拟基类 BaseDest提供简单重载成员函数的子类被定义为 DestImpl<T> .我使用这个基类来维护 DestImpl<T> 的动态集合实例，具有不同的 T .此类提供了 assign() 的显式重载成员函数；一个 double * ，还有一个 float * .这个想法是在运行时，BaseDest::assign()通过多态指针或引用调用，这又调用正确的虚拟 assign() DestImpl<T> 中的成员函数.

现在，重要的是数组的非指针类型匹配 DestImpl<T> 中的 T。 , 那一个fast_copy()调用函数(可能是 memcpy)，当类型不匹配时，将执行较慢的静态逐项复制。所以 assign()成员函数将其卸载到模板化的仿函数。这个仿函数有两种特化 - 一种是仿函数的类型参数与 DestImpl<T> 的类型相匹配。 (并因此调用一个快速拷贝)，以及一个捕获所有其他情况的回退拷贝(并调用一个慢速拷贝)。

但是，我无法编译以下代码。注释显示了编译器错误和警告出现的位置——我怀疑它们是相关的。我不明白的是为什么apply_helper的第二个特化无法实例化为 apply_helper<double> .

class BaseDest {
public:
  virtual ~BaseDest() {}

  virtual void assign(const double * v, size_t cnt) = 0;
  virtual void assign(const float * v, size_t cnt) = 0;
};

template <typename T>
class DestImpl : public BaseDest {
public:

  void assign(const double * v, size_t cnt) {
    assign_helper<T>()(v, cnt);
  }
  void assign(const float * v, size_t cnt) {
    assign_helper<T>()(v, cnt);  // ERROR: no matching function for call to object of type 'assign_helper<double>'

  }   
protected:

  template <typename U>
  struct assign_helper {
    void operator()(const U * v, size_t cnt) {
      for (size_t i = 0; i < cnt; ++i) {
        //slow_copy(v[i]);
      }
    }
  };

  template <typename U>
  struct assign_helper<T> {  // WARNING: Class template partial specialization contains a template parameter that can not be deduced; this partial specialization will never be used

    void operator()(const T * v, size_t cnt) {
      //fast_copy(v, cnt);
    }
  };
};

void test() {
  DestImpl<double> d;  // error mentioned above appears when this is present
}

编辑:这似乎确实有效——移动 assign_helper DestImpl<T> 中的结构(现在是一个类)类定义。我不确定这是正确的方法，但到目前为止它似乎确实有效:

// slow copy between different types
template <typename T, typename U>
class assign_helper {
public:
  void operator()(const U *v, size_t cnt) {
    // slow copy
  }
};

// fast copy between same types
template <typename T>
class assign_helper<T, T> {
public:
  void operator()(const T * v, size_t cnt) {
    // fast copy
  }
};


class BaseDest {
public:
  virtual ~BaseDest() {}

  virtual void assign(const double * v, size_t cnt) = 0;
  virtual void assign(const float * v, size_t cnt) = 0;
};

template <typename T>
class DestImpl : public BaseDest {
public:

  virtual void assign(const double * v, size_t cnt) {
    assign_helper<T, double>()(v, cnt);
  }
  virtual void assign(const float * v, size_t cnt) {
    assign_helper<T, float>()(v, cnt);
  }
};

Answer 1

template <typename U>
  struct assign_helper<T> {  // WARNING: Class template partial specialization contains a template parameter that can not be deduced; this partial specialization will never be used

以上是你错误的原因。该警告明确告诉您永远不会使用此定义。你想要什么而不是 template < typename U >是template <> .