C++模板功能专用化

C++ template function specialization

本文关键字：专用 功能 C++      更新时间：2023-10-16

我必须为定义为以下内容的模板类实现一个非成员函数isHomogeneus（Triple triple）：

template <typename T1, typename T2, typename T3>
    class Triple
{
public:
    Triple()
    { }
    Triple(const T1 &a, const T2 &b, const T3 &c) : a(a), b(b), c(c)
    { }
...

isHomogeneus 函数应返回一个布尔值，指示参数三元组中的所有三个值是否属于同一类型。我试过：

template <typename T> bool isHomogenous(Triple<T, T, T> triple) {
    return true;
}
template <typename T1, typename T2, typename T3> bool isHomogenous(Triple<T1, T2, T3> triple) {
    return false;
}

这行不通，你能提示我一个解决方案吗？

函数模板不能部分专用化。

一种替代方法是将其定义为类模板的静态成员函数（或者在您的情况下只是一个值！），然后只提供一个普通的函数模板包装器，例如......

#include <type_traits>
template< class T1, class T2, class T3 >
struct Blah {};
namespace detail {
    template< class T1, class T2, class T3 >
    struct IsHomogenous { static bool const yes = false; };
    template< class T >
    struct IsHomogenous< T, T, T > { static bool const yes = true; };
}  // namespace detail
template< class T1, class T2, class T3 >
bool isHomogenous( Blah< T1, T2, T3 > )
{
    return detail::IsHomogenous< T1, T2, T3 >::yes;
}
#include <iostream>
int main()
{
    using namespace std;
    wcout << boolalpha
        << isHomogenous( Blah< double, char, void >() ) << " "
        << isHomogenous( Blah< int, int, int >() )
        << endl;
}

另一种方法是使用 C++11 std::is_same：

#include <type_traits>
template< class T1, class T2, class T3 >
struct Blah {};
template< class T1, class T2, class T3 >
bool isHomogenous( Blah< T1, T2, T3 > )
{
    using std::is_same;
    return is_same< T1, T2 >::value && is_same< T2, T3 >::value;
}
#include <iostream>
int main()
{
    using namespace std;
    wcout << boolalpha
        << isHomogenous( Blah< double, char, void >() ) << " "
        << isHomogenous( Blah< int, int, int >() )
        << endl;
}

您不能专用化模板函数，当您添加专用化时，专用函数实际上被添加到重载集中，因此它与重载相同，并且用于选择要调用的函数使用重载解析规则。

如果确实要专用模板函数，请委托给具有静态成员的结构或类，并改为专用化模板结构：

template <typename T>
struct handler
{
   static void perform(T& );
};
template <>
struct handler<int>
{
   static void perform(int) { doStuff(); }
};

这是全局函数（您要专门化）：

template <typename T>
void function (T& v)
{
   handler<T>::perform(v);
}

希望这有帮助。

您可以使用函数

部分专用化一个类，该函子将返回 true 或 false。 （或静态成员，无论什么）：

template< class T1, class T2, class T3 >
class Blah {};
template< class T>
struct isHomogenous
{
    const bool operator()() { return false; }
};
template< template <typename,typename,typename> class T, class T1, class T2, class T3 >
struct isHomogenous<T<T1,T2,T3>>
{
    const bool operator()() { return false; }
};

template< template <typename,typename,typename> class T, class T1>
struct isHomogenous<T<T1,T1,T1>>
{
    const bool operator()() { return true; }
};
std::cout << isHomogenous< Blah<double, char, void> >()() << " "
    << isHomogenous< Blah<int, int, int> >()();
相关文章：