我应该如何做这个明确的专业化？

Question

是否可以使用设计？：

template <typename T>
class Test{
 public:
  template <typename Z>
  void doSomething();
  //rest of things
 private:
  T obj;
  //some things
};

现在，如果可能的话，我会做一些明确的专业，以便最终我有一些版本，例如以下内容：

void doSomething<int>(){
 //do something
}
void doSomething<double>(){
 //do something
}
...etc

这似乎是不可能的，我找不到任何语法可以完成这项工作，然后我认为设计应该如下所述，以便所有模板参数都应传递给模板类本身：

template <typename T,typename Z>
class Test{
 public:
  void doSomething();
  //rest of things
 private:
  T obj;
  //some things
};

然后，我尝试了部分专业化，甚至没有编译：

template <typename T>
void Test<T,int>::doSomething(){
 //do something
}
template <typename T>
void Test<T,double>::doSomething(){
 //do something
}
...etc

我有以下明确专业化的错误：
错误＃1：模板参数列表以下类模板名称必须在模板参数列表中使用的顺序中列出参数。
错误＃2：'Container1'：太少的模板参数。

Answer 1

为了明确专业 doSomething 您还必须明确专业 Test.

从14.7.3/18：

在命名空间范围中出现的类模板成员或成员模板的成员的明确专业声明中，成员模板及其某些封闭类模板可能会保持无专业， 除非声明不得明确专业，如果其封闭类模板也没有明确专业化.

Answer 2

除非其封闭的类模板也明确专业，否则您不能明确专业化会员模板。

因此，只有这样的事情才能起作用：

template<> template<>
void Test<int>::doSomething<int>()
{
}

Answer 3

您随时可以在线函数

template <class T>
class Test
{
public:
 template <class Z>
 void doSomething() { cout << "default" << endl; }

 template<>
 void doSomething<int>() { cout << "int" << endl;}
 template<>
 void doSomething<double>() { cout << "double" << endl; }
private:
 T obj;
};

Answer 4

我认为这很挑剔。我想你做不到，阅读 这个.

Answer 5

不确定这是否是G ++中的错误，但这会编译并产生我的期望。

#include<typeinfo>
#include<iostream>

template<typename T>
class Test
{
public:
    template<typename Z>
    void doSomething();

private:
    T obj;
};

template<typename T>
template<typename Z>
void Test<T>::doSomething()
{
    Z val;
    std::cout << __func__ << ": type " << typeid(val).name() << std::endl;
}

int main(int argc, char *argv[])
{
    Test<double> a;
    a.doSomething<int>();
    a.doSomething<double>();
}

Answer 6

冰淇淋发布了一个临时答案，并且由于Visual C ++ 2008的一些错误而被汇编而成：

template <typename T>
class Test{
 public:
  template <typename Z>
  void doSomething();
  //rest of things
 private:
  T obj;
  //some things
};
template <>
template <typename T>
void Test<T>::doSomething<int>(){
 //do something
}

虽然检查他当前的答案。至少在VC ++ 2008中，有趣的事情是，专门处理内联定义时没有问题，但是对于具有不在内部定义的专业化，一旦有一个以上的版本，它就不会成功地汇编。