C++ 迭代器作为C++；？

我在以下简单代码中遇到问题：

  void foo (vector<int>:: iterator it, vector<int> n)
  {
       vector<int>:: iterator it2 = it +1;
       while (it2!=n.end())
       {
           cout<<*it2<<endl;
           it2++;
       }
  }
  main()
  {
        vector<int> m{1,2,3,4};
        vector<int>:: iterator it = m.begin();
        foo (it, m);
  }

void foo（向量：：迭代器it，向量n） { 向量：：迭代器it2=it+1； while（it2！=n.end（）） { 不能将

向量n

作为副本传递。因此，

it2

指向不同的向量（在

main

中创建的向量）。检查

it2！=n.end（）

无效，因为

it2

是另一个向量的迭代器

通过引用传递

n

是一种解决方案。另一种解决方案是传递结束迭代器而不是向量

要将向量作为常量引用传递，请执行以下操作：

void foo (vector<int>:: iterator it, const vector<int>& n)

voidfoo（向量：：迭代器it，常量向量&n）

要传递结束迭代器，请执行以下操作：

void foo (vector<int>::iterator it, vector<int>::iterator end)
{
 ...
     while ( it2 != end )
 ...
}

void foo（vector:：iterator it，vector:：iterator end） { ... while（it2！=结束） ... } 您将

向量n

作为副本传递。因此您的

it2

指向不同的向量（在

main

中创建的向量）。您的检查

it2！=n.end（）

无效，因为

it2

是另一个向量的迭代器

通过引用传递

n

是一种解决方案。另一种解决方案是传递结束迭代器而不是向量

要将向量作为常量引用传递，请执行以下操作：

void foo (vector<int>:: iterator it, const vector<int>& n)

voidfoo（向量：：迭代器it，常量向量&n）

要传递结束迭代器，请执行以下操作：

void foo (vector<int>::iterator it, vector<int>::iterator end)
{
 ...
     while ( it2 != end )
 ...
}

void foo（vector:：iterator it，vector:：iterator end） { ... while（it2！=结束） ... }

---

是的，这是可能的。但请注意迭代器是绑定到其容器的

---

函数的第二个参数是由参数copy构造的，即

向量n

是

main

中定义的

向量m

的副本。因此，函数尝试将迭代器与另一个迭代器（

.end（）

）进行比较从另一个容器。您最好同时传递begin/end迭代器而不是container。

是的，这是可能的。但请注意迭代器与其容器绑定

---

函数的第二个参数是由参数copy构造的，即

向量n

是

main

中定义的

向量m

的副本。因此，函数尝试将迭代器与另一个迭代器（

.end（）

）进行比较从不同的容器。最好同时传递begin/end迭代器而不是container。

您有两个问题：一个是，正如Satus和yeputons所指出的，您传递的是向量参数的副本

第二个问题是，如果参数为空，

foo

的第一行已经是非法的。也就是说，即使是微不足道的修正

void foo (vector<int>:: iterator it, vector<int> &n)
{
   vector<int>:: iterator it2 = it +1;

你奇怪的跳过第一个元素的设计让它看起来有点难看，更好的方法是让一些实用程序帮助跳过第一个元素，然后使用复制：

template <typename Iterator>
Iterator try_advance(Iterator i, int count, Iterator end)
{
  for (; count-- > 0 && i != end; ++i)
    ;
  return i;
}


void foo (vector<int>::iterator begin, vector<int>::iterator end)
{
   // skip first element of a non-empty range
   // leave an empty range un-damaged
   begin = try_advance(begin, 1, end);
   std::copy(begin, end, std::ostream_iterator<int>(std::cout, '\n'));
}

模板
迭代器try_advance（迭代器i、int计数、迭代器end）
{
对于（；计数-->0&&i！=end；++i）
;
返回i；
}
void foo（向量：：迭代器开始，向量：：迭代器结束）
{
//跳过非空范围的第一个元素
//保持空范围未损坏
开始=尝试前进（开始，1，结束）；
std:：copy（开始、结束、std:：ostream_迭代器（std:：cout，'\n'））；
}

您有两个问题：一个是您正在传递向量参数的副本，正如Satus和yeputons已经指出的那样

第二个问题是，如果参数为空，

foo

的第一行已经是非法的。也就是说，即使是微不足道的修正

void foo (vector<int>:: iterator it, vector<int> &n)
{
   vector<int>:: iterator it2 = it +1;

你奇怪的跳过第一个元素的设计让它看起来有点难看，更好的方法是让一些实用程序帮助跳过第一个元素，然后使用复制：

template <typename Iterator>
Iterator try_advance(Iterator i, int count, Iterator end)
{
  for (; count-- > 0 && i != end; ++i)
    ;
  return i;
}


void foo (vector<int>::iterator begin, vector<int>::iterator end)
{
   // skip first element of a non-empty range
   // leave an empty range un-damaged
   begin = try_advance(begin, 1, end);
   std::copy(begin, end, std::ostream_iterator<int>(std::cout, '\n'));
}

模板
迭代器try_advance（迭代器i、int计数、迭代器end）
{
对于（；计数-->0&&i！=end；++i）
;
返回i；
}
void foo（向量：：迭代器开始，向量：：迭代器结束）
{
//跳过非空范围的第一个元素
//保持空范围未损坏
开始=尝试前进（开始，1，结束）；
std:：copy（开始、结束、std:：ostream_迭代器（std:：cout，'\n'））；
}

n

是

m

的一个副本，它的迭代器与

it

无关，因为您将m作为值传递，所以n的地址空间与原始m的地址空间不同，因为n是m的副本。

n

是

m

的副本，它的迭代器与

it

无关，因为您将m作为值传递地址n的空间与原始m的空间不同，因为n是m的副本。