2

我正在尝试为在整数值（而不是类型）上模板化的函数编写动态调度程序。虽然我可以编写代码生成器或使用大型宏链来创建调度程序源，但模板化解决方案似乎更优雅。

我已经将我的调度程序简化为一个简单的形式（实际上并没有进行任何调度）：

// works fine with full template specialization
template <int N>
struct TestDispatcher1D {
  int f(int n) {
    if (n == N) return n; // replace me with actual dispatch
    TestDispatcher1D<N-1> t;
    return t.f(n);
  }
};

template<>
struct TestDispatcher1D<-1> {
  int f(int n) { return -1; }
};

// partial template specialization is problematic
template <int M, int N>
struct TestDispatcher2D {
  int f(int m, int n);
};

template<int M>
struct TestDispatcher2D<M,-1> {
  int f(int m, int n) { return -1; }
};

template<int N>
struct TestDispatcher2D<-1,N> {
  int f(int m, int n) { return -1; }
};

template<>
struct TestDispatcher2D<-1,-1> {
  int f(int m, int n) { return -1; }
};

template <int M, int N>
int TestDispatcher2D<M,N>::f(int m, int n) {
  if ((n == N) && (m == M)) return n + m; // replace me with actual dispatch
  if (m < M) {
    if (n < N) {
      TestDispatcher2D<M-1,N-1> t;
      return t(m,n);
    } else {
      TestDispatcher2D<M-1,N> t;
      return t(m,n);
    }
  } else {
    TestDispatcher2D<M,N-1> t;
    return t(m,n);
  }
}

// test code
void testIt() {
  { 
    TestDispatcher1D<16> t; 
    t.f(16); 
  }
  {
    TestDispatcher1D<16>t; 
    t.f(0);
  }
  {
    TestDispatcher2D<16,16>t; 
    t.f(8,8);
  }
}

在 gcc 4.1.1 上编译它时，我收到以下错误：

t.cpp：在成员函数'int TestDispatcher2D::f(int, int) [with int M = 16, int N = 16]'中：
t.cpp:63：从这里实例化
t.cpp:40: 错误: 调用 '(TestDispatcher2D) (int&, int&)' 不匹配
t.cpp:63：从这里实例化
t.cpp:43: 错误: 调用 '(TestDispatcher2D) (int&, int&)' 不匹配
t.cpp:63：从这里实例化
t.cpp:47: 错误: 调用 '(TestDispatcher2D) (int&, int&)' 不匹配

显然，当我尝试创建递归对象时，编译器并没有将其视为实例化新模板的请求。

有什么建议么？

4

1 回答 1

1

您只是没有f()在递归调用中调用该函数，而是在尝试“调用对象”：

你写：

TestDispatcher2D<...> t;
return t(m,n);

但你想要：

TestDispatcher2D<...> t;
return t.f(m,n);
于 2009-02-18T16:15:08.900 回答