我有一个类 vec_base
定义如下:
template<typename T, std::size_t Size>
class vec_base;
我想专门化它以便
vec_base<float, /* any multiple of 4 */>
和
vec_base<double, /* any multiple of 2 */>
可以有独立的特定成员,比如
vec_base<int, 6>
这将具有我已经定义的通用成员
我很难实现这个,因为允许的大小很宽松(4 或 2 的任何倍数),如果它具体是 2 或 4 我知道我可以执行完全特化,但事实并非如此:/
我该怎么做?感谢任何帮助,我一直喜欢学习新的语言技巧!
编辑
好的,到目前为止我有这个:
template<std::size_t Size>
struct is_div_by_4{static const bool value = (Size % 4 == 0);};
// have to define because of template requirements
// about not being dependent on other parameters
template<typename T, std::size_t Size, bool is_special>
class vec_base;
template<typename T, std::size_t Size>
class vec_base<T, Size, false>{
// generic implementation
};
teplate<std::size_t Size>
class vec_base<float, Size, is_div_by_4<Size>::value>{
// Special implementation (for sse, it's no secret)
};
但我还没有编译它,我知道它不会起作用,所以请不要指出这一点;这就是我目前所拥有的,以防你认为我只是将自己的工作推迟到 SO。
最佳答案
简单的解决方案
最简单的技术是使用 std::enable_if
和 std::same
类似于你所做的:
template<typename T, std::size_t Size, typename U = void>
class vec_base { /* implement me generically */ };
template<typename T, std::size_t Size>
class vec_base<T, Size, typename std::enable_if<std::is_same<T, float>::value && Size % 4 == 0>::type>
{ /* implement me with 10% more awesome-sauce */ };
template<typename T, std::size_t Size>
class vec_base<T, Size, typename std::enable_if<std::is_same<T, double>::value && Size % 2 == 0>::type>
{ /* implement me with pepper instead */ };
为什么 typename U = void
可以避免
背后的想法std::enable if
是一种称为 SFINAE 原则的东西,它基本上指出,无论何时实例化模板不起作用,编译器都不会出错,而只是从所有重载集和类似的名称解析中删除该定义。
std::enable_if
背后的实现特化类模板,因此 std::enable_if<false>
不包含成员type
根本。因此,使用该类型成员将导致错误(由于 SFINAE)从考虑中删除此特化。
由于您的模板已经包含一个类型参数,您可以改为使用该类型参数,因为 std::enable_if<true>::type
其实和它的第二个参数是一样的,一个类型参数,只默认为void
, 但当然可以设置。
因此,您可以完全删除通用实现中的最后一个模板参数,而是像这样专门化:
template<typename T, std::size_t Size>
class vec_base<typename std::enable_if<std::is_same<T, float>::value && Size % 4 == 0, float>::type, Size>
{ /* implement me with 10% more awesome-sauce */ };
为什么 typename T
和 std::same
没有必要
从这里您还可以看到您可以删除 typename T
您的专业并放弃使用 std::is_same
. T
毕竟必须始终是特定类型...
template<std::size_t Size>
class vec_base<typename std::enable_if<Size % 4 == 0, float>::type, Size>
{
friend vec_base operator+(vec_base const& lhs, vec_base const& rhs)
{ /* do some additions */
return lhs;
}
};
在类之外添加更多运算符非常简单:
// works for all vec_base variants
template<typename T, std::size_t Size>
vec_base<T, Size> operator-(vec_base<T, Size> const& lhs, vec_base<T, Size> const& rhs)
{ /* do some subtractions */
return lhs;
}
// works only for the specialization float, divisible by 4
template<std::size_t Size>
typename std::enable_if<Size % 4 == 0, vec_base<float, Size>>::type
operator-(vec_base<float, Size> const& lhs, vec_base<float, Size> const& rhs)
{ /* do some salty computations */
return lhs;
}
这实际上是可行的,因为第二个版本比第一个版本受到更严格的限制(每个与特殊功能一起使用的参数组也适用于通用功能 - 但通用功能有一些特殊功能无法使用) .
修正你的尝试
虽然您似乎对自己的尝试感到失望,但这里是如何使其也能正常工作的方法(请注意,此解决方案比上面显示的解决方案复杂得多):
template<typename T, std::size_t Size, int mode =
(std::is_same<T, float>::value && Size % 4 == 0) ? 1
: (std::is_same<T, double>::value && Size % 2 == 0) ? 2
: 0>
struct vec_base;
template<typename T, std::size_t Size>
struct vec_base<T, Size, 0>
{ static void hello() { ::std::cout << "hello all\n"; } };
template<std::size_t Size>
struct vec_base<float, Size, 1>
{ static void hello() { ::std::cout << "hello 4 floats\n"; } };
template<std::size_t Size>
struct vec_base<double, Size, 2>
{ static void hello() { ::std::cout << "hello 2 doubles\n"; } };
你可以这样调用它:
vec_base<float, 2>::hello(); // hello all
vec_base<float, 4>::hello(); // hello 4 floats
关于c++ - 类型的部分模板特化,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/23319865/