c++ - 整数类型的模板函数特化

Question

假设我有一个模板函数：

template<typename T>
void f(T t)
{
    ...
}

我想为所有原始整数类型编写一个特化。做这个的最好方式是什么？

我的意思是：

template<typename I where is_integral<I>::value is true>
void f(I i)
{
    ...
}

并且编译器为整数类型选择第二个版本，而为其他所有类型选择第一个版本？

Answer 1

使用SFINAE

// For all types except integral types:
template<typename T>
typename std::enable_if<!std::is_integral<T>::value>::type f(T t)
{
    // ...
}

// For integral types only:
template<typename T>
typename std::enable_if<std::is_integral<T>::value>::type f(T t)
{
    // ...
}

请注意，即使是声明，您也必须包含完整的std::enable_if返回值。

C++17 更新：

// For all types except integral types:
template<typename T>
std::enable_if_t<!std::is_integral_v<T>> f(T t)
{
    // ...
}

// For integral types only:
template<typename T>
std::enable_if_t<std::is_integral_v<T>> f(T t)
{
    // ...
}

Answer 2

我会使用重载决议。这使您不必使用粗俗的 SFINAE hack。不幸的是，有很多领域是您无法避免的，但幸运的是，这不是其中之一。

template<typename T>
void f(T t)
{
  f(t, std::is_integral<T>());
}

template<typename T>
void f(T t, std::true_type)
{ 
  // ...
}

template<typename T>
void f(T t, std::false_type)
{ 
  // ...
}

Answer 3

使用 c++11，可以使用 std::enable_if ( http://en.cppreference.com/w/cpp/types/enable_if ) 来做到这一点：

template<typename T, class = typename std::enable_if<std::is_integral<T>::value>::type>
void f(T t) {...}

Answer 4

您可以使用可以像这样专门化的帮助模板：

#include <string>
#include <iostream>
#include <type_traits>

template <typename T, bool = std::is_integral<T>::value>
struct Foo {
        static void bar(const T& t) { std::cout << "generic: " << t << "\n"; }
};
template <typename T>
struct Foo<T, true> {
        static void bar(const T& t) { std::cout << "integral: " << t << "\n"; }
};

template <typename T>
static void bar(const T& t) {
        return Foo<T>::bar(t);
}

int main() {
        std::string s = "string";
        bar(s);
        int i = 42;
        bar(i);
        return 0;
}

输出：

generic: string
integral: 42

Answer 5

这是 C++20 解决方案

template<std::integral T>
void f(T v) {
   ...
}

我认为它实际上是重载的功能，但工作方式相同。

Answer 6

通过在函数体内实现不同的版本来获得更直接、更易读的方式呢？

    template<typename T>
    void DoSomething(T inVal) {
        static_assert(std::is_floating_point<T>::value || std::is_integral<T>::value, "Only defined for float or integral types");
        if constexpr(std::is_floating_point<T>::value) {
            // Do something with a float
        } else if constexpr(std::is_integral<T>::value) {
            // Do something with an integral
        }
    }

您不必担心性能。条件是编译时间常数，下降编译器会将它们优化掉。不幸的是，“如果 constexpr”是 c++17，但是当两个版本都编译且两种类型都没有错误时，您可以删除“constexpr”