我应该怎么做而不是函数模板的部分专业化？

Question

我想写以下内容：

template <typename S, typename T> void foo() {
    /* code for the general case */
}

template <typename T> void foo<MySType,T>() {
    /* partially specialized code - for any kind of T, but when S is MySType */
}

或者，在其他情况下，如下：

template <typename S, typename T> void bar(const S& a, const T& b) {
    /* code for the general case */
}

template <typename T> void bar<MySType,T>(const MySType& a, const T& b) {
    /* partially specialized code - for any kind of T, but when S is MySType */
}

C++(11) 不允许我这样做。

现在，我读到了this question and its answers；假设我购买了为什么我们没有部分模板专业化的解释（或者只是假设我生活在现实中并且实际上想要编写代码）。好吧，我做什么，而不是？

我真的不想将这些函数包装在一个类中，除非那绝对是我最后的手段。

Answer 1

超载！重载在各方面都优于专业化。重载解决方案的一部分是选择最专业的重载。只需将“专业化”声明为重载，如果有部分专业化，它将起作用。

不过，请避免使用显式模板参数。您可以改用标签调度。

template< typename t >
struct tag {};

template <typename S, typename T> foo( tag<S>, tag<T> ) {
    /* code for the general case */
}

template <typename T> foo( tag<MyType>, tag<T> ) {
    /* partially specialized code - for any kind of T, but when S is MyType */
}

由于标签为空且按值传递，编译器可能会消除它们对函数调用开销的影响。

Answer 2

另一种选择是使用帮助类模板，您可以在其中进行部分特化，并使用本身不需要部分特化的包装函数将其隐藏：

#include <iostream>

template<typename S, typename T>
struct foo_helper {
    void foo() {
        std::cout << "general func" << std::endl;        
    }
};

struct MyType {};

template <typename T>
struct foo_helper <MyType,T> {
    void foo() {   
        std::cout << "partially specialized code - for any kind of T, but when S is MyType" << std::endl;
    }
};

template<typename S, typename T>
void foo() {
    foo_helper<S, T>().foo();
}

int main () {
    foo<int, int>();
    foo<int, double>();
    foo<MyType, long>();
}

这也是有效的 C++98/03。

Answer 3

您可能会部分专门化一个辅助结构：

#include <iostream>

namespace Detail {
    template <typename S, typename T>
    struct Foo {
        static void apply() {
            std::cout << "general case\n";
        }
    };
    template <typename T>
    struct Foo<int, T> {
        static void apply() {
            std::cout << "specialized code\n";
        }
    };
}

template <typename S, typename T>
void foo() {
    Detail::Foo<S, T>::apply();
}

int main()
{
    foo<double, double>();
    foo<int, double>();
    return 0;
}