模板類的專用模板函數

Question

我有一個索引函數，並試圖將其專用於標準容器類型，但會得到錯誤。我確信它不是簡單的就是不可能的，但我不記得哪一個。我更喜歡這些作爲功能對象，但我無法做到這一點。是否有可能專門的模板函數模板類

namespace std { //declarations of predefined indexable types 
    template <class T, class A> class vector; 
    //others are here too, but all have the same issue 
} 
//default indexer 
template <class T> 
double indexer(const T& b) { //this seems to work fine 
    return b.getIndex(); 
} 
// base types 
template<> double indexer<char>(const char& b) { return double(b); } 
//other primitives are here too, and work fine 
// standard library 
template<class T, class A> 
double indexer<std::vector<T,A>>(const std::vector<T,A>& b) 
{ return b.empty() ? 0 : indexer(*b.cbegin()); } //line with error 

錯誤消息：

error C2768: 'indexer' : illegal use of explicit template arguments 

我想爲這是專業化VS超載，因爲我有一個函數A，需要一個功能對象/指針模板參數，以及使用默認索引器調用第一個A的重載函數A。

template<class T, class function> 
double A(T a, function F) { return F(a);} //complicated 
template<class T> 
double A(T a) {return A(a, indexer<T>);} //default wrapper 

這似乎很有可能這是一個重複的問題，但我似乎無法找到一個。

Answer 1

由於函數不能部分專用，我可以用函數對象替換索引函數。這似乎工作正常，並解決了我所有的問題。

namespace std { //declarations of predefined indexable types 
    template <class T, class A> class vector; 
} 
template <class T> 
struct indexer { 
    double operator()(const T& b) const 
    { return b.getIndex(); } 
}; 
template<> struct indexer<char> { 
    double operator()(const char& b) const 
    { return double(b); } 
}; 
template<class T, class A> struct indexer<std::vector<T,A>> { 
    double operator()(const std::vector<T,A>& b) const 
    { return b.empty() ? 0 : indexer(*b.cbegin()); } 
}; 

template<class T, class function> 
double A(T a, function F) { return F(a);} //complicated 
template<class T> 
double A(T a) {return A(a, indexer<T>());} //default wrapper 

Answer 2

您不能部分專門化模板功能，只能模板類。

超載使用，而不是：

namespace std { //declarations of predefined indexable types 
     template <class T, class A> class vector; 
} 
//default indexer 
template <class T> 
double indexer(const T& b) { return b.getIndex(); } 

double indexer(const char& b) { return double(b); } 

template<class T, class A> 
double indexer(const std::vector<T,A>& b) 
{ return b.empty() ? 0 : indexer(*b.cbegin()); } 

Answer 3

這裏只對過載提供基於解決方案，使用C++ 11式可變參數模板：

template <typename T> 
T print(const T & t) 
{ 
    std::cout << t << std::endl; 
    return t; 
} 

template <template <typename...> class Container, typename ...Args> 
typename Container<Args...>::value_type print(const Container<Args...> & v) 
{ 
    typedef typename Container<Args...>::value_type T; 

    if (v.empty()) std::cout << "nil" << std::endl; 
    else std::cout << *v.begin() << std::endl; 

    return v.empty() ? T() : *v.begin(); 
} 

如果你想成爲幻想，如果你有訪問is_container類型特徵（例如從pretty printer獲取），可以使容器過載特定於容器，使用enable_if：

template <template <typename...> class Container, typename ...Args> 
typename std::enable_if<is_container<Container<Args...>>::value, 
         typename Container<Args...>::value_type>::type 
print(const Container<Args...> & v) 
{ 
    /* ... */ 
}