C++ C+的问题+；部分模板专门化

我的情况与此类似：

template<class A, class B>
class MyClass<A, B>
{
  ...
  static A RARELY_USED_A;
}

// Seems to work but does not cover all possible cases, since 
// there may be instances of A that have no numeric limits.
template<class A, class B>
A MyClass<A, B>::RARELY_USED_A= std::numeric_limits<A>::max();

模板
类MyClass
{
...
静态A很少使用A；
}
//似乎有效，但并未涵盖所有可能的情况，因为
//可能存在没有数字限制的实例。
模板
MyClass:：Narrow_USED_A=std:：numeric_limits:：max（）；

据我所见，这似乎是可行的。然而，字符串在某些情况下可能被用作一个特殊的字符串，因此我认为我应该为这个特殊情况创建一个专门化

// Does not complile
template<class B>
string MyClass<string, B>::RARELY_USED_A= "";

//不兼容
模板
字符串MyClass：：很少使用；

不幸的是，这与错误消息不符：

error: template definition of non-template 'std::string MyClass<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, B>::RARELY_USED_A'

错误：非模板“std:：string MyClass:：novely_USED_A”的模板定义

请注意，另一方面，完全的专门化似乎是可行的（在运行时未测试，但可以编译）

//这是符合要求的，但不够格尼奇，因此对我来说没有用
模板
字符串MyClass：：很少使用；

我想，我一定是做错了什么。如果你能指出它的确切含义，我将不胜感激。我以为分词专精应该是这样的

先谢谢你

---

e:将默认值的名称编辑为“很少使用”，因为我认为“默认值”在某种程度上具有误导性

您需要对整个类进行部分专门化，而不仅仅是单个成员。

使用继承来重用和专门化，而不复制所有公共代码：

template<typename A>
struct RarelyUsedShared
{
    static A RARELY_USED_A;
};

template<typename A>
A RarelyUsedShared<A>::RARELY_USED_A = std::numeric_limits<A>::max();

template<>
string RarelyUsedShared<string>::RARELY_USED_A = "";

template<typename A, typename B>
class MyClass<A, B> : RarelyUsedShared<A>
{
  ...
};

---

如果您的

很少使用

是const，您可以使用一个小助手类：

template <class A, class B>
const A MyClass<A, B>::RARELY_USED_A = Helper<A>::value;

/*...*/

#include <limits>
#include <string>

template <typename A> struct Helper { static const A RARELY_USED_A; };
template <typename A> const A Helper<A>::RARELY_USED_A = std::numeric_limits<A>::max();

template <> struct Helper<std::string> { static const std::string RARELY_USED_A; };
const std::string Helper<std::string>::RARELY_USED_A = "";

模板
常量A MyClass:：很少使用\U A=Helper:：value；
/*...*/
#包括
#包括
模板结构助手{很少使用的静态常量}；
模板常数A Helper:：很少使用_A=std:：numeric_limits:：max（）；
模板结构助手{static const std:：string很少使用_A；}；
const std:：string Helper:：很少使用；

hmm，这真的很烦人，因为这只会是所有内容的重复代码，而不是单个成员的重复代码。我还想知道为什么只有这一个成员才可能实现完全的专门化。@b.buchhold：使用一个helper类，它只有这一个成员。然后您可以专门化它，而无需代码复制。您的主类可以从中继承。。。。是的，有点痛。请注意，在您的工作案例n.m.中，您根本不是专门化函数，而是为

MyClass

的一个专门模板实例的一个成员提供定义。我想。是的，这是一种可怕的、疯狂的、荒谬的痛苦。谢谢。听起来不错。我仍然想知道为什么会有这种局部专业化的限制。但我想这个答案以一种优雅的方式解决了我的问题。现在我有了另一个问题。由于MyClass是一种容器类型，有许多可能的安装，因此我无法将其拆分为.h和.cpp文件，而必须将整个内容都放在头文件中。不幸的是，这样做是我从使用MyClass的多个对象链接二进制文件时很少使用的多个定义。@b.buchhold：这是一个全新的问题，即使没有专门化，您也会遇到这个问题，需要单独提问。此外，我认为它已经得到了回答，所以首先搜索“模板静态多定义”。我认为这不会编译，因为如果我没有记错的话，对于静态/常量内容，函数调用和字符串初始化都是不可能的。即使在C++0x中

max（）

是

constepr

？但是，我们还没有测试它，所以这可能不起作用。

静态

成员必须在类外部定义，即使它们在类内部初始化。

template<typename A, typename B>
struct RarelyUsedNotShared
{
    static A RARELY_USED_A;
};

template<typename A, typename B>
A RarelyUsedNotShared<A, B>::RARELY_USED_A = std::numeric_limits<A>::max();

template<typename B>
struct RarelyUsedNotShared<string, B>
{
    static A RARELY_USED_A;
};

typename<typename B>
string RarelyUsedNotShared<string, B>::RARELY_USED_A = "";

template<typename A, typename B>
class MyClass<A, B> : RarelyUsedNotShared<A, B>
{
  ...
};

template <class A, class B>
const A MyClass<A, B>::RARELY_USED_A = Helper<A>::value;

/*...*/

#include <limits>
#include <string>

template <typename A> struct Helper { static const A RARELY_USED_A; };
template <typename A> const A Helper<A>::RARELY_USED_A = std::numeric_limits<A>::max();

template <> struct Helper<std::string> { static const std::string RARELY_USED_A; };
const std::string Helper<std::string>::RARELY_USED_A = "";