类型的部分模板专业化

时间：2014-04-27 05:45:00

标签： c++ templates c++11 specialization

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

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

3 个答案:

答案 0 :(得分：7)

简单解决方案

最简单的方法是使用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

答案 1 :(得分：2)

更简单：

template<typename T, std::size_t Size>
class vec_base
{
  public: vec_base() {
      std::cout << "I am generic, my size is " << Size << std::endl;
  }
};

template<std::size_t Size>
class vec_base<typename std::enable_if<Size % 4 == 0, float>::type, Size>
{
  public: vec_base() {
      std::cout << "I am specialized for float, my size is " << Size << std::endl;
  }
};

template<std::size_t Size>
class vec_base<typename std::enable_if<Size % 2 == 0, double>::type, Size>
{
  public: vec_base() {
      std::cout << "I am specialized for double, my size is " << Size << std::endl;
  }
};

答案 2 :(得分：2)

将您的特殊性封装在类型特征

中

我会选择is_special<T, N>类型特征，为所有不适合您的SSE解决方案的类型提供std::false_type，否则提供std::true_type。

#include <cstddef>
#include <iostream>
#include <type_traits>

// test whether a vector of floating points fits into B bits SSE solution
template<typename T, std::size_t N, std::size_t B = 128>
struct is_special
: 
    std::integral_constant<bool, 
        std::is_floating_point<T>::value && 8 * sizeof(T) * N == B
    > 
{};

我通常不喜欢将原始条件放在我的模板特化中使用这些特性，因为这会导致代码的可维护性降低（特别是如果你在其他任何地方重用类型特征）。

使用enable_if

专门化您的模板

然后，您可以对此类型特征执行std::enable_if 

template<typename, std::size_t, typename = void>
class vec_base
{
public:
    static void print() { std::cout << "vec_base<T, N>\n"; };    
};

template<std::size_t N>  
class vec_base<float, N, typename std::enable_if<is_special<float, N>::value>::type>
{
public:
    static void print() { std::cout << "vec_base<float, 4 * K>\n"; };    
};

template<std::size_t N> 
class vec_base<double, N, typename std::enable_if<is_special<double, N>::value>::type>
{
public:
    static void print() { std::cout << "vec_base<double, 2 * K>\n"; };    
};

请注意，通用模板无需了解您用于特化的特殊条件的类型。这是开放/封闭原则的一个表现：您的代码已关闭以进行修改，但对于扩展而言是开放的。对于128位长的双打，只需添加一个新的专业。

在实践中测试代码

您可以像这样调用此代码：

int main()
{
    vec_base<int, 6>::print();    // vec_base<T, N>
    vec_base<float, 1>::print();  // vec_base<T, N>
    vec_base<float, 4>::print();  // vec_base<float, 4 * K>
    vec_base<double, 1>::print(); // vec_base<T, N>
    vec_base<double, 2>::print(); // vec_base<double, 2 * K>
}

Live Example打印上面的注释行。重要的是要测试你想要的案例和你不想调用SSE代码的案例。

相关问题
最新问题