std :: vector <T>

Question

我試圖編寫一個模板函數來處理任何類型的參數，包括向量，地圖等，但我遇到了麻煩。

template<class C> 
void foo(C c); 

template<> 
template<class V> 
void foo<std::vector<V> >(std::vector<V> v); 

編譯器（G ++ 4.9.2-10）會抱怨這樣的：

test.cpp:13:43: error: too many template parameter lists in declaration of ‘void foo(std::vector<V>)’ 
void foo<std::vector<V> >(std::vector<V> v) { 
             ^
test.cpp:13:6: error: template-id ‘foo<std::vector<V> >’ for ‘void foo(std::vector<V>)’ does not match any template declaration 
void foo<std::vector<V> >(std::vector<V> v) { 
    ^
test.cpp:13:43: note: saw 2 ‘template<>’, need 1 for specializing a member function template 
void foo<std::vector<V> >(std::vector<V> v) { 
             ^

我怎樣才能做到這一點？ 我也想專注於的std ::地圖<的std :: string，V >

從專業化去除第一模板< >線仍然無法正常工作（非法專業化）

Answer 1

你不能偏特一個功能，您要創建一個新的重載：

template<class C> 
void foo(C c); 

template<class V> 
void foo(std::vector<V> v); // This is an overload, not a specialization! 

請注意，使用的foo部分專業化的區別：

template<class C> 
void foo(C c); // 1 

template<class V> 
void foo<std::vector<V>>(std::vector<V> v); // 2 

這裏是2的部分特化，這在C++中是不允許的。

Answer 2

根據容器的特性，您可能會發現方便過載。

這允許在接受引用，常量引用和r值引用方面稍微靈活一點，而只寫一次函數。

這是它實現了一個模板foo爲任何具有begin()和end()方法，除了標準::字符串，它通過一個非模板超載都有自己的foo版本的一個小例子：

#include <vector> 
#include <map> 
#include <iostream> 
#include <iomanip> 

// trait type to determine whether something models a range. 
template<class T> 
struct is_range 
{ 
    template <class Y> static auto has_begin(T*p) -> decltype(p->begin(), void(), std::true_type()); 
    template <class Y> static auto has_begin(...) -> decltype(std::false_type()); 

    template <class Y> static auto has_end(T*p) -> decltype(p->end(), void(), std::true_type()); 
    template <class Y> static auto has_end(...) -> decltype(std::false_type()); 

    static constexpr bool value = decltype(has_begin<T>(0))::value && decltype(has_end<T>(0))::value; 
}; 


// specialised mini-functor for dealing with corner cases 
template<class T> 
struct emitter 
{ 
    std::ostream& operator()(std::ostream& os, const T& t) const { 
     return os << t; 
    } 
}; 

template<class T, class U> 
struct emitter<std::pair<T, U>> 
{ 
    std::ostream& operator()(std::ostream& os, const std::pair<T, U>& p) const 
    { 
     return os << "(" << p.first << ", " << p.second << ")"; 
    } 
}; 

// a version of foo which works for all known containers, whether temporararies or references 
template<class Container, 
std::enable_if_t<is_range<std::decay_t<Container>>::value and not std::is_same<std::decay_t<Container>, std::string>::value>* = nullptr 
> 
void foo(Container&& c) 
{ 
    // do things with c.begin(), c.end() 
    bool first = true; 
    for (auto& x : c) { 
     using emitter_type = emitter<std::decay_t<decltype(x)>>; 
     auto emit = emitter_type(); 
     if (first) { 
      first = false; 
     } else { 
      std::cout << ", "; 
     } 
     emit(std::cout, x); 
    } 
    std::cout << std::endl; 
} 

// overload for std string 

void foo(const std::string& s) 
{ 
    std::cout << std::quoted(s) << std::endl; 
} 

int main() 
{ 
    using namespace std::literals; 

    foo(std::map<std::string, std::string> { 
     { 
      { { "foo" }, { "bar" } }, 
      { { "aaaa" }, { "bbbbb" } } 
     } 
    }); 
    foo(std::vector<std::string> { 
     { "foo" }, 
     { "bar" }, 
     { "xxxx" }, 
     { "yyyy" } }); 

    foo("hello"s); 

} 

預期輸出：

(aaaa, bbbbb), (foo, bar) 
foo, bar, xxxx, yyyy 
"hello"