我有一个类 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/