C++ 单模板功能，显示不同容器的内容

我有一个向量容器，它是使用：

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

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

向量v1；
v1.推回（1）；
v1.推回（2）；
v1.推回（3）；

和deque容器，其构造使用：

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

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

deque-deq；
设计前推（1）；
向前推（2）；
向前推（3）；

我希望有一个模板函数来显示这两个容器的内容以及所有数据类型的内容。为了处理不同的数据类型，我制作了如下模板函数：

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

模板
无效显示（矢量向量）
{
对于（int i=0；icout我想您可能会使用基于范围的for循环：

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

模板
无效显示（常数C和容器）
{
用于（const auto&e：集装箱）
{
std:：cout我想您可能会使用基于范围的for循环：

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

模板
无效显示（常数C和容器）
{
用于（const auto&e：集装箱）
{
std：：cout大概是这样的：

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

模板
无效显示（常数C和容器）{
std：：复制（std：：开始（容器），std：：结束（容器），
std:：ostream_迭代器（std:：cout，“\n”）；
}
大概是这样的：

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

模板
无效显示（常数C和容器）{
std：：复制（std：：开始（容器），std：：结束（容器），
std:：ostream_迭代器（std:：cout，“\n”）；
}
许多STL容器都支持将范围和对作为值类型，因此

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

#包括
#包括
#包括
#包括
使用std：：cout；
使用std：：endl；
名称空间详细信息{
模板
无效打印元素（常量标准：：对和对）{
cout许多STL容器都支持将范围和对作为值类型，所以

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

#包括
#包括
#包括
#包括
使用std：：cout；
使用std：：endl；
名称空间详细信息{
模板
无效打印元素（常量标准：：对和对）{
无法解释为什么
decltype（*std:：begin（容器））
而不是
typename C:：value\u type
？@Caleth为什么不这样做？这样对
C
的要求更少。这不会为容器的每个元素调用副本构造函数吗？@jschultz410它不会看到对
ostream\u迭代器的赋值reference@jschultz410我觉得自己像一个迭代器
是在
std:：copy
之上的黑客，而不是
std:：copy
在其个人所做的事情中不一般，为什么
decltype（*std:：begin（container））
而不是
typename C:：value\u type
？@Caleth为什么不这样做？这样对
C
的要求更少。这不会为容器的每个元素调用副本构造函数吗？@jschultz410它不会看到对
ostream\u迭代器的赋值reference@jschultz410我觉得自己像一个迭代器
是对
std:：copy
的一种攻击，而不是
std:：copy
在它的个人用途上不是通用的，我很好奇（对不起，我无能为力），为什么只为std:：pair做一个特例？@jschultz410，因为像
std:：unordered_map
和
std:：map
这样的容器在使用迭代器进行迭代时，会将
std:：pair
作为值类型。STL容器使用的其他值包装器有没有我没有考虑到的？我想我会如果你想变得更一般，你应该专门研究std:：tuple。我的观点是，可能有各种类型都没有输出运算符。我只是想知道为什么你会选择std:：pair进行特殊处理。我想这是一个很好的理由，因为它是标准库中的常见类型。好奇，我好奇（对不起，我无能为力），为什么只为std:：pair做一个特例？@jschultz410，因为像
std:：unordered_map
和
std:：map
这样的容器在使用迭代器进行迭代时，会将
std:：pair
作为值类型。STL容器使用的其他值包装器有没有我没有考虑到的？我想我会如果你想变得更一般，你应该专门研究std:：tuple。我的观点是，可能有各种类型都没有输出运算符。我只是想知道为什么你会选择std:：pair进行特殊处理。我想这是一个很好的理由，因为它是标准库中的常见类型。