我應該做什麼而不是功能模板的部分專業化？

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

另一種方法是使用一個輔助類模板，在那裏你可以做部分特化，並使用它不需要包裝函數隱藏它被部分專業本身：

#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 2

超載！在任何專業化方面，超載都是優越的。重載解決方案的一部分是挑選最專業的過載。只要將「專業化」聲明爲重載，並且如果部分專業化就會有效。

避免明確的模板參數，雖然。您可以使用標籤分派。

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 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; 
}