有没有办法为函数模板专业化命名类型？

Question

例如，当我们有一个通用的函数模板时，我们可以在函数中使用模板类型：

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

现在，想象一下这个函数模板的特化：

template <>
void foo<MySpecialType>()
{
  T t; // Does not compile, no knowledge of formal template argument T
  MySpecialType t2; // This is OK, but I have to mention MySpecialType again
}

template <>
void foo<MySpecialType2>()
{
  T t; // Does not compile, no knowledge of formal template argument T
  MySpecialType2 t2; // This is OK, but I have to mention MySpecialType2 again
}

请注意，在上述两种特化中，我必须提到在函数体内按名称特化的模板参数的类型。我宁愿使用更通用的占位符（即 T），而不是在函数模板特化的主体中重复（可能多次）被特化的类型。

如果有一种方法可以在实际的专业化函数定义处使用 T 或创建别名，那就太好了。我知道我可以通过实际函数体内的类型别名来做到这一点：

template<>
void foo<MySpecialType>
{
  using T=MySpecialType; // But then I still repeat the type at least once
  ...

我更喜欢这样的专业化约定：

// Warning: Not valid C++
template<>
void foo<T=MySpecialType>
{
  T t;
  ...

或者：

// Warning: Not valid C++
template<T>
void foo<MySpecialType>
{
  T t;
  ...

感谢您的建议。

Answer 1

你可以这样做：

template <typename T>
struct bar
{
    using Type = T;

    static void foo();
};

template <typename T>
void bar<T>::foo()
{
    Type t;
    // ...
}

template <>
void bar<MySpecialType>::foo()
{
    Type t;
    // ...
}

template <>
void bar<MySpecialType2>::foo()
{
    Type t;
    // ...
}

template <typename T>
void foo()
{
    bar<T>::foo();
}

但是你真的需要它吗？

Answer 2

这是可行的。以下是一个使用部分特化的工作解决方案，并且是一个包含静态函数的类模板：

template<typename T, typename U = void>
struct foo_impl
{
    static void bar()
    {
        ::std::cout << "T\n";
    }
};

template<typename T>
struct foo_impl<T, typename ::std::enable_if<::std::is_same<T, int>::value>::type>
{
    static void bar()
    {
        ::std::cout << "int\n";
    }
};

template<typename T>
void foo()
{
    foo_impl<T>::bar();
}