C++ 中非模板类的专门成员函数

Question

我试图使用模板化参数专门化非模板类的模板成员函数：

#include <array>
class C
{
public:
  template<class Container>
  void Foo( Container& )
  {
    // ...
  }
};

template<class T, std::size_t N>
template<>
void C::Foo< std::tr1::array<T,N> >( std::tr1::array<T,N>& )
{
  // special
}

我收到错误“非法使用显式模板参数”。使其有效的正确语法是什么？

---

更新：

也许我因过度简化而混淆了问题。我真正想做的是专门处理这种情况，其中涉及一个依赖名称，我认为这可能是给这里的工作带来麻烦的原因。我最初的想法是这样重载该函数：

class C
{
public:
  template<class Iter>
  void Foo( Iter )
  {
    std::cout << "Normal\n";
  }

  template<class T, std::size_t N>
  void Foo( typename std::tr1::array<T,N>::iterator )
  {
    std::cout << "Special\n";
  }
};

int main()
{
  C c;
  std::tr1::array<int,10> a1;
  c.Foo( a1.begin() ); // Doesn't print "Special"!
}

但是特殊的 Foo 不会被调用。我怎样才能做到这一点？

Answer 1

只有成员函数是模板化的，这意味着您只能在其中使用一个 template<...> 。但这也不能解决问题，因为你不能部分特化一个函数。

处理问题的通常方法是通过重载，而不是特化（模板函数的特化没有那么有用）。

struct test {
   template <typename Container>
   void f( Container& ) { ... }

   template <typename T, int N>
   void f( std::array<T,N>& ) { ... }
};

请注意，区别在于它们是两个独立的模板函数（而不是专门化）。

编辑：更新后

问题的更新完全改变了问题。您看到的问题是第二个版本的参数是一个从属名称，因此它是不可推论的。给定函数调用，编译器无法确定什么类型 T 和整型常量 N 与该特定实例相匹配。考虑一个不同的示例：

template <typename T>
struct inner_int {
   typedef int type;
};
template <typename T>
void foo( typename inner_int<T>::type ) {
}
int main() {
   foo( inner_int<double>::type() );
}

当编译器处理 main 中的调用时，它会实例化模板并提取类型，从中创建一个临时变量，然后尝试决定如何处理 foo 但当时它只知道它是用 int 右值调用的......原来的 inner::type 消失了，现在它只是 foo( int() ) 并且编译器必须尝试使用​​所有可能的类型实例化 inner_int 以确定它们中的任何一个是否适合，并且在最坏的情况下，如上所述，许多会匹配。

Answer 2

部分函数模板特化是非法的。来自 C++03 标准，§14/2：

模板声明只能作为命名空间范围或类范围声明出现。在函数模板声明中，declarator-id 应为模板名称 （即不是模板 ID）< /强>。 [注意：在类模板声明中，如果类名是template-id，则该声明声明类模板部分特化。]

您只需重载您的函数：

class C
{
public:
    template<typename Container>
    void Foo(Container&)
    {
        // ...
    }

    template<typename T, std::size_t N>
    void Foo(std::tr1::array<T, N>&)
    {
        // special
    }
};

---

编辑（响应OP的编辑）：

如果您只是在寻找针对此特定场景的解决方法，因为std(::tr1)::array::iterator 只是 T*，您的“特殊”重载可以是：

template<typename T>
void Foo(T*&)
{
    // special
}