模板类中单个方法的模板特化

Question

始终考虑到包含我的模板类的以下标头至少包含在两个 .CPP 文件中，此代码可以正确编译：

template <class T>
class TClass 
{
public:
  void doSomething(std::vector<T> * v);
};

template <class T>
void TClass<T>::doSomething(std::vector<T> * v) {
  // Do something with a vector of a generic T
}

template <>
inline void TClass<int>::doSomething(std::vector<int> * v) {
  // Do something with a vector of int's
}

但请注意专业化方法中的内联。需要避免由于方法被多次定义而导致链接器错误（在VS2008中是LNK2005）。我理解这一点是因为据我所知，完整的模板专业化与简单的方法定义相同。

那么，如何删除该内联？代码不应在每次使用时重复。我搜索过 Google，阅读了 SO 中的一些问题，并尝试了许多建议的解决方案，但没有成功构建（至少在 VS 2008 中没有）。

谢谢！

Answer 1

与简单函数一样，您可以使用声明和实现。
放入您的标头声明：

template <>
void TClass<int>::doSomething(std::vector<int> * v);

并将实现放入您的 cpp 文件之一：

template <>
void TClass<int>::doSomething(std::vector<int> * v) {
 // Do somtehing with a vector of int's
}

不要忘记删除内联（我忘记了，并认为此解决方案不起作用:)）。
在VC++2005上检查过

Answer 2

您需要将专业化定义移至 CPP 文件。
即使函数未声明为模板，也允许对模板类的成员函数进行特化。

Answer 3

没有理由删除关键字 inline。
无论如何，它不会改变代码的含义。

Answer 4

如果您出于某种原因想要删除内联，maxim1000 的解决方案是完全有效的。

不过，在您的评论中，您似乎认为 inline 关键字意味着包含所有内容的函数始终被内联，但据我所知，这实际上很大程度上取决于您的编译器优化。

引用自 C++ 常见问题解答

有多种方法可以指定函数是内联的，其中一些
其中涉及 inline 关键字，其他则不涉及。不管你如何
将一个函数指定为内联函数，这是编译器的要求
允许忽略：编译器可能会内联展开部分、全部或无
调用指定为内联函数的位置。 （不
如果这看起来非常模糊，你会感到沮丧。的灵活性
上面实际上是一个巨大的优势：它让编译器可以处理大的
功能与小功能不同，而且它让编译器
如果选择正确的编译器，生成易于调试的代码
选项。）

因此，除非您知道该函数实际上会使您的可执行文件膨胀，或者除非您出于其他原因想将其从模板定义标头中删除，否则您实际上可以将其保留在原处而不会造成任何损害

Answer 5

这有点过时了，但我想我会把它留在这里，以防它对其他人有帮助。我在谷歌上搜索模板专业化，这导致我来到这里，虽然@maxim1000的答案是正确的并最终帮助我解决了我的问题，但我认为它还不够清楚。

我的情况与OP的情况有点不同（但我认为足够相似，可以留下这个答案）。基本上，我使用的是第三方库，其中包含定义“状态类型”的所有不同类型的类。这些类型的核心只是枚举，但这些类都继承自公共（抽象）父级，并提供不同的实用函数，例如运算符重载和静态 toString(enum type) 函数。每个状态enum 彼此不同并且互不相关。例如，一个enum具有字段NORMAL、DEGRADED、INOPERABLE，另一个具有AVAILBLE、PENDING、MISSING等。我的软件负责管理不同组件的不同类型的状态。我想对这些 enum 类使用 toString 函数，但由于它们是抽象的，我无法直接实例化它们。我本可以扩展我想要使用的每个类，但最终我决定创建一个 template 类，其中 typename 将是任何具体状态 enum > 我关心。对于这一决定可能会有一些争论，但我觉得这比用我自己的自定义类扩展每个抽象枚举类并实现抽象函数要少得多。当然，在我的代码中，我只是希望能够调用 .toString(enum type) 并让它打印该 enum 的字符串表示形式。由于所有 enum 完全不相关，因此它们每个都有自己的 toString 函数，这些函数（经过我了解的一些研究后）必须使用模板专门化来调用。这把我引到了这里。下面是为了使这项工作正常工作我必须做的 MCVE。实际上我的解决方案与@maxim1000 的有点不同。

这是enum 的（大大简化的）头文件。实际上，每个 enum 类都是在其自己的文件中定义的。该文件代表作为我正在使用的库的一部分提供给我的头文件：

// file enums.h
#include <string>

class Enum1
{
public:
  enum EnumerationItem
  {
    BEARS1,
    BEARS2,
    BEARS3
  };

  static std::string toString(EnumerationItem e)
  {
    // code for converting e to its string representation,
    // omitted for brevity
  }
};

class Enum2
{
public:
  enum EnumerationItem
  {
    TIGERS1,
    TIGERS2,
    TIGERS3
  };

  static std::string toString(EnumerationItem e)
  {
    // code for converting e to its string representation,
    // omitted for brevity
  }
};

添加此行只是为了将下一个文件分隔到不同的代码块中：

// file TemplateExample.h
#include <string>

template <typename T>
class TemplateExample
{
public:
  TemplateExample(T t);
  virtual ~TemplateExample();

  // this is the function I was most concerned about. Unlike @maxim1000's
  // answer where (s)he declared it outside the class with full template
  // parameters, I was able to keep mine declared in the class just like
  // this
  std::string toString();

private:
  T type_;
};

template <typename T>
TemplateExample<T>::TemplateExample(T t)
  : type_(t)
{

}

template <typename T>
TemplateExample<T>::~TemplateExample()
{

}

下一个文件

// file TemplateExample.cpp
#include <string>

#include "enums.h"
#include "TemplateExample.h"

// for each enum type, I specify a different toString method, and the
// correct one gets called when I call it on that type.
template <>
std::string TemplateExample<Enum1::EnumerationItem>::toString()
{
  return Enum1::toString(type_);
}

template <>
std::string TemplateExample<Enum2::EnumerationItem>::toString()
{
  return Enum2::toString(type_);
}

下一个

// and finally, main.cpp
#include <iostream>
#include "TemplateExample.h"
#include "enums.h"

int main()
{
  TemplateExample<Enum1::EnumerationItem> t1(Enum1::EnumerationItem::BEARS1);
  TemplateExample<Enum2::EnumerationItem> t2(Enum2::EnumerationItem::TIGERS3);

  std::cout << t1.toString() << std::endl;
  std::cout << t2.toString() << std::endl;

  return 0;
}

文件，此输出：

BEARS1
TIGERS3

不知道这是否是理想的解决我的问题的解决方案，但它对我有用。现在，无论我最终使用多少种枚举类型，我所要做的就是在 .cpp 文件中为 toString 方法添加几行，然后我就可以使用已经定义的库< code>toString 方法，无需自己实现它，也无需扩展我想要使用的每个 enum 类。

Answer 6

我想补充一点，如果您打算将专门化也保留在头文件中，那么仍然有充分的理由保留 inline 关键字。

“直观上，当您完全专门化某些东西时，它不再依赖于模板参数 - 因此除非您将专门化内联，否则您需要将其放入 .cpp 文件而不是 .h 中，否则您最终违反了单一定义规则......”

参考：https://stackoverflow.com/a/4445772/1294184