clang-如何在头文件中声明静态常量int

Question

给定头文件中的以下模板和几个专业化：

template<typename> class A {
static const int value;
};
template<> const int A<int>::value = 1;
template<> const int A<long>::value = 2;

使用clang-5构建时，会导致包含该文件的每个源单元出现错误，所有这些都抱怨A<int>::value和A<long>::value有多个定义。

起初，我认为模板专业化可能需要放在一个特定的翻译单元中，但在检查规范时，这显然是允许的，因为值是一个常量整数。

我是不是做错了什么？

EDIT：如果我将定义移动到一个翻译单元中，那么我就不能再在const int的上下文中使用A<T>::value的值(例如，它的值用于计算另一个常量赋值的值)，所以该值确实需要在标头中。

Answer 1

在c++11中，您也许可以这样做：

template<typename> class B {
public:
static const int value = 1;
};
template<> class B<long> {
public:
static const int value = 2;
};
template<typename T> const int B<T>::value;

如果您只想专门化值var，那么可以使用CRTP。

从C++17，您可以使您的定义内联：

template<> inline const int A<int>::value = 1;
template<> inline const int A<long>::value = 2;

也可以从c++17中删除"template const int B:：value；"对于constexpr:

template<typename> class C {
public:
static constexpr int value = 1;
};
template<> class C<long> {
public:
static constexpr int value = 2;
};
// no need anymore for: template<typename T> const int C<T>::value;

c++11的另一个解决方案是使用内联方法，而不是c++17:中允许的内联变量

template<typename T> class D { 
public:
static constexpr int GetVal() { return 0; }
static const int value = GetVal();
};  
template <> inline constexpr int D<int>::GetVal() { return 1; }
template <> inline constexpr int D<long>::GetVal() { return 2; }
template< typename T>
const int D<T>::value;

除了上次编辑：

为了在其他依赖定义中也使用您的值，如果您使用内联constexpr方法，它似乎是最可读的版本。

编辑：clang的"特殊"版本，因为正如OP所告诉的那样，clang抱怨"实例化后发生的特殊化"。我不知道clang或gcc在那个地方是错的。。。

template<typename T> class D {
public:
static constexpr int GetVal();
static const int value;
};

template <> inline constexpr int D<int>::GetVal() { return 1; }
template <> inline constexpr int D<long>::GetVal() { return 2; }
template <typename T> const int D<T>::value = D<T>::GetVal();
int main()
{
std::cout << D<int>::value << std::endl;
std::cout << D<long>::value << std::endl;
}

我已经告诉过，如果不重新定义完整的类，CRTP是可能的。我在clang上检查了代码，它编译时没有任何警告或错误，因为OP评论说他不知道如何使用它：

template<typename> class E_Impl {
public:
static const int value = 1;
};
template<> class E_Impl<long> {
public:
static const int value = 2;
};
template<typename T> const int E_Impl<T>::value;
template < typename T>
class E : public E_Impl<T>
{
// rest of class definition goes here and must not specialized
// and the values can be used here!
public:
void Check()
{
std::cout << this->value << std::endl;
}
};

int main()
{
E<long>().Check();
std::cout << E<long>::value << std::endl;
E<int>().Check();
std::cout << E<int>::value << std::endl;
}