一个模板专门用于多个类

Question

假设我们有一个模板函数“foo”：

template<class T>
void foo(T arg)
{ ... }

我可以对某些特定类型进行专门化，例如，

template<>
void foo(int arg)
{ ... }

如果我想对所有内置数字类型（int、float、double 等）使用相同的专门化，我会多次编写这些行。我知道主体可以被扔到另一个函数中，并且只需在每个专业化的主体中进行调用即可，但是如果我可以避免为每种类型编写此“void foo(...”，那就更好了。有没有可能告诉编译器我想对所有这些类型使用这个专门化？

Answer 1

您可以使用 std::numeric_limits 来查看类型是否是数字类型（对于所有浮点和整数基本类型，is_specialized 均为 true）。

// small utility
template<bool> struct bool2type { };

// numeric
template<typename T>
void fooImpl(T arg, bool2type<true>) {

}

// not numeric
template<typename T>
void fooImpl(T arg, bool2type<false>) {

}

template<class T>
void foo(T arg)
{ fooImpl(arg, bool2type<std::numeric_limits<T>::is_specialized>()); }

Answer 2

您可以使用带有预处理器的方法。

foo.inc:

template<>
void foo(TYPE arg)
{ /* do something for int, double, etc. */ }

foo.h:

template<class T>
void foo(T arg)
{ /*do something */ }

#define TYPE int
#include "foo.inc"
#undef TYPE

#define TYPE double
#include "foo.inc"
#undef TYPE

等

Answer 3

使用 boost：

#include <boost/type_traits/is_scalar.hpp>
#include <iostream>
#include <string>

namespace detail
{
    typedef const boost::true_type& true_tag;
    typedef const boost::false_type& false_tag;

    template <typename T>
    void foo(const T& pX, true_tag)
    {
        std::cout << "special: " << pX << std::endl;
    }

    template <typename T>
    void foo(const T& pX, false_tag)
    {
        std::cout << "generic: " << pX << std::endl;
    }
}

template <typename T>
void foo(const T& pX)
{
    detail::foo(pX, boost::is_scalar<T>());
}

int main()
{
    std::string s = ":D";
    foo(s);
    foo(5);
}

您可以在不使用 boost 的情况下轻松完成：

#include <iostream>
#include <string>

// boolean stuff
template <bool B>
struct bool_type {};

typedef bool_type<true> true_type;
typedef bool_type<false> false_type;

// trait stuff
template <typename T>
struct is_scalar : false_type
{
    static const bool value = false;
};

#define IS_SCALAR(x) template <> \
            struct is_scalar<x> : true_type \
            { \
                static const bool value = true; \
            };

IS_SCALAR(int)
IS_SCALAR(unsigned)
IS_SCALAR(float)
IS_SCALAR(double)
// and so on

namespace detail
{
    typedef const true_type& true_tag;
    typedef const false_type& false_tag;

    template <typename T>
    void foo(const T& pX, true_tag)
    {
        std::cout << "special: " << pX << std::endl;
    }

    template <typename T>
    void foo(const T& pX, false_tag)
    {
        std::cout << "generic: " << pX << std::endl;
    }
}

template <typename T>
void foo(const T& pX)
{
    detail::foo(pX, is_scalar<T>());
}

int main()
{
    std::string s = ":D";
    foo(s);
    foo(5);
}

Answer 4

也许您可以定义一个适用于所有本机类型的默认模板函数，并将自定义类型的专业化委托给用户

Answer 5

您可以编写一个小脚本（例如 Perl）来为您生成源文件。创建一个包含所有要专门化的类型的数组，并让它写出每个类型的函数头。您甚至可以将脚本执行嵌入到 makefile 中，以便在更改某些内容时自动重新运行它。

注意：这假设 foo 的实现对于每种类型都可以变得简单且相似，例如，只需调用真正的实现函数。但它避免了一堆模板/预处理器的胡言乱语，这可能会让未来的维护者摸不着头脑。

Answer 6

这是约翰内斯解决方案的改进，但更易于阅读。只需在函数内部进行类型检查：

template<typename T>
void foo(T arg)
{
  if (numeric_limits<T>::is_specialized)  // not a runtime check - compile time constant
  {
  }
  else
  {
  }
}

使用类型特征（本身就是模板专业化）允许用单个易于阅读的函数模板替换一堆模板专业化