2017-06-17 6 views
0

ich einen Vektor Container habe welches unter Verwendung:einzelne Template-Funktion Inhalte verschiedenen Container anzuzeigen

vector<int> v1; 
v1.push_back(1); 
v1.push_back(2); 
v1.push_back(3); 

Und deque Behälter aufgebaut mit:

deque<int> deq; 
deq.push_front(1); 
deq.push_front(2); 
deq.push_front(3); 

Ich mag eine Template-Funktion haben, die anzeigt Inhalt dieser beiden Container und für alle Datentypen. Für den Umgang mit unterschiedlichen Datentypen habe ich eine Template-Funktion wie folgt aus:

template <typename T> 
void display(vector<T> vec) 
{ 
    for(int i = 0; i < vec.size(); ++i) 
    { 
     cout << vec[i] << endl; 
    } 
    cout << endl; 
} 

Zur Zeit seiner Arbeits für Vektor, Wie kann ich es für alle Behälter wie deque und Liste funktioniert?

Antwort

2

Ich denke, man verwenden könnte bereichsbasierte for-Schleife:

template<typename C> 
void display(const C& container) 
{ 
    for (const auto& e : container) 
    { 
     std::cout << e << std::endl; 
    } 
} 
3

Etwas in dieser Richtung, vielleicht:

template <typename C> 
void display(const C& container) { 
    std::copy(std::begin(container), std::end(container), 
    std::ostream_iterator<decltype(*std::begin(container))>(std::cout, "\n")); 
} 
+0

Warum 'declltype (* std :: begin (container))' anstelle von 'typename C :: value_type'? – Caleth

+2

@Caleth Warum nicht? Auf diese Weise werden weniger Anforderungen an "C" gestellt. –

+0

Ruft dies nicht einen Kopierkonstruktor für jedes Containerelement auf? – jschultz410

1

Viele STL-Container unterstützen Bereiche mit Paaren als Werttypen so

#include <iostream> 
#include <deque> 
#include <vector> 
#include <map> 

using std::cout; 
using std::endl; 

namespace detail { 
    template <typename First, typename Second> 
    void print_element(const std::pair<First, Second>& pr) { 
     cout << pr.first << " " << pr.second << endl; 
    } 

    template <typename Type> 
    void print_element(const Type& element) { 
     cout << element << endl; 
    } 
} // namespace detail 

template <typename Container> 
void print_all(const Container& container) { 
    for (const auto& element : container) { 
     detail::print_element(element); 
    } 
} 


int main() { 

    auto v = std::vector<int>{1, 2, 3}; 
    auto d = std::deque<int>{1, 2, 3}; 
    auto m = std::map<int, int>{{1, 2}}; 
    print_all(v); 
    print_all(d); 
    print_all(m); 

    return 0; 
} 
+1

Neugierig, ich bin neugierig (sorry konnte nicht helfen), warum machst du einen speziellen Fall nur für std :: pair? – jschultz410

+0

@ jschultz410 weil viele Container wie 'std :: unordered_map' und' std :: map' '' std :: pair' haben, da der Wert bei der Iteration mit iteriert. Gibt es einen anderen Wert-Wrapper, den STL-Container verwendet haben, den ich übersehen habe? – Curious

+1

Ich denke, wenn Sie allgemeiner sein wollten, würden Sie sich für std :: tuple spezialisieren. Mein Punkt war, dass es wahrscheinlich alle Arten von Typen gibt, die keinen Ausgabeoperator haben. Ich habe mich nur gefragt, warum du std :: pair für eine spezielle Behandlung ausgesucht hast. Ich denke, weil es ein üblicher Typ in der Standardbibliothek ist, ist das ein guter Grund. – jschultz410

Verwandte Themen