C++ 标准库容器的通用输出函数

我玩模板。使用它们可以从容器类型中提取，例如，下面的向量可以是任何POD类型

template<class T>
void show(vector<T> &a) {
typename vector<T>::iterator end = a.end(), start = a.begin();
  for(start; start!= end; start++) {
      cout<<*start<<" ";
   }
 }

模板
无效显示（矢量和a）{
typename向量：：迭代器end=a.end（），start=a.begin（）；
for（开始；开始！=结束；开始++）{
cout不使用容器作为参数，而是使用一对迭代器：

template <typename Iter>
void show(Iter first, Iter last) {
  while (first != last) {
    cout << *first++;
  }
}

vector<int> v;
show(v.begin(), v.end());
deque<int> d;
show(d.begin(), d.end());
int arr[10];
show(begin(arr), end(arr));

模板
无效展示（国际热核聚变实验堆第一，国际热核聚变实验堆最后）{
while（第一个！=最后一个）{
cout不使用容器作为参数，而是使用一对迭代器：

template <typename Iter>
void show(Iter first, Iter last) {
  while (first != last) {
    cout << *first++;
  }
}

vector<int> v;
show(v.begin(), v.end());
deque<int> d;
show(d.begin(), d.end());
int arr[10];
show(begin(arr), end(arr));

模板
无效展示（国际热核聚变实验堆第一，国际热核聚变实验堆最后）{
while（第一个！=最后一个）{
cout不使用容器作为参数，而是使用一对迭代器：

template <typename Iter>
void show(Iter first, Iter last) {
  while (first != last) {
    cout << *first++;
  }
}

vector<int> v;
show(v.begin(), v.end());
deque<int> d;
show(d.begin(), d.end());
int arr[10];
show(begin(arr), end(arr));

模板
无效展示（国际热核聚变实验堆第一，国际热核聚变实验堆最后）{
while（第一个！=最后一个）{
cout不使用容器作为参数，而是使用一对迭代器：

template <typename Iter>
void show(Iter first, Iter last) {
  while (first != last) {
    cout << *first++;
  }
}

vector<int> v;
show(v.begin(), v.end());
deque<int> d;
show(d.begin(), d.end());
int arr[10];
show(begin(arr), end(arr));

模板
无效展示（国际热核聚变实验堆第一，国际热核聚变实验堆最后）{
while（第一个！=最后一个）{
cout
模板无效显示（续）{
副本（cbegin（c）、cend（c）、ostream_迭代器（cout，”）；
}
模板无效显示（续）{
副本（cbegin（c）、cend（c）、ostream_迭代器（cout，”）；
}
模板无效显示（续）{
副本（cbegin（c）、cend（c）、ostream_迭代器（cout，”）；
}
模板无效显示（续）{
副本（cbegin（c）、cend（c）、ostream_迭代器（cout，”）；
}
您的解决方案已经非常接近了。只需删除向量规范即可&它将起作用

template<typename T> void show(T& a)
{
    auto end = a.end();
    auto start = a.begin();
    for(start; start != end; start++)
    {
        cout << *start << " ";
    }
}

int main(int, char**)
{
    vector<int> a(2,100);
    show(a);
    list<double> b(100, 3.14);
    show(b);
    return 0;
}

模板无效显示（T&a）
{
自动结束=a.end（）；
自动启动=a.begin（）；
for（开始；开始！=结束；开始++）
{
cout您的解决方案已经非常接近了。只需删除向量规范即可&它将起作用

template<typename T> void show(T& a)
{
    auto end = a.end();
    auto start = a.begin();
    for(start; start != end; start++)
    {
        cout << *start << " ";
    }
}

int main(int, char**)
{
    vector<int> a(2,100);
    show(a);
    list<double> b(100, 3.14);
    show(b);
    return 0;
}

模板无效显示（T&a）
{
自动结束=a.end（）；
自动启动=a.begin（）；
for（开始；开始！=结束；开始++）
{
cout您的解决方案已经非常接近了。只需删除向量规范即可&它将起作用

template<typename T> void show(T& a)
{
    auto end = a.end();
    auto start = a.begin();
    for(start; start != end; start++)
    {
        cout << *start << " ";
    }
}

int main(int, char**)
{
    vector<int> a(2,100);
    show(a);
    list<double> b(100, 3.14);
    show(b);
    return 0;
}

模板无效显示（T&a）
{
自动结束=a.end（）；
自动启动=a.begin（）；
for（开始；开始！=结束；开始++）
{
cout您的解决方案已经非常接近了。只需删除向量规范即可&它将起作用

template<typename T> void show(T& a)
{
    auto end = a.end();
    auto start = a.begin();
    for(start; start != end; start++)
    {
        cout << *start << " ";
    }
}

int main(int, char**)
{
    vector<int> a(2,100);
    show(a);
    list<double> b(100, 3.14);
    show(b);
    return 0;
}

模板无效显示（T&a）
{
自动结束=a.end（）；
自动启动=a.begin（）；
for（开始；开始！=结束；开始++）
{
我也可以。我也可以。我也可以。我也可以。@KerrekSB：当然，你首先需要一个合适的
操作符，因为我很想。实际上我没有通过迭代器，因为我可以调用容器，比如vector:：insert或map:：insert等通用方法。使用迭代器，我不能在数组的末尾添加新元素。或者，例如，我不能调用vector：：clear（）方法。但它可以用于输出（而且我的问题已经改变了）@KerrekSB：嗯，当然你首先需要一个合适的
操作符，因为我很想。实际上我没有通过迭代器，因为我能够调用容器，比如vector:：insert或map:：insert。使用迭代器，我不能在数组的末尾添加新元素。或者，例如，我不能调用vector:：clear（）方法。但是输出很好（而且我的问题已经改变了）@KerrekSB：嗯，当然你首先需要一个合适的
操作符，因为我很想。实际上我没有通过迭代器，因为我能够调用容器，比如vector:：insert或map:：insert。使用迭代器，我不能在数组的末尾添加新元素。或者，例如，我不能调用vector:：clear（）方法。但是输出很好（而且我的问题已经改变了）@KerrekSB：嗯，当然你首先需要一个合适的
操作符，因为我很想。实际上我没有通过迭代器，因为我能够调用容器，比如vector:：insert或map:：insert。使用迭代器，我不能在数组的末尾添加新元素。或者，例如，我不能调用vector:：clear（）方法。但是输出很好（而且我的问题已经改变了）