类型的部分模板专业化

Question

我有一个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)
};

但我还没有编译它,我知道它不会起作用,所以请不要指出这一点; 这就是我到目前为止的想法,因为你认为我只是把自己的工作推迟到了.

Answer 1

简单解决方案

最简单的技术是使用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