标签: iterator

如果我交换两个向量,它们的迭代器是否仍然有效,现在只是指向"其他"容器,或者迭代器是否会失效？

那是,给定:

using namespace std;
vector<int> x(42, 42);
vector<int> y;
vector<int>::iterator a = x.begin(); 
vector<int>::iterator b = x.end();

x.swap(y);

// a and b still valid? Pointing to x or y?

似乎std没有提到这个:

[n3092 - 23.3.6.2]

void swap(vector<T,Allocator>& x);

效果:将*的内容和容量()与x的内容和容量()进行交换.

请注意,因为我在VS 2005上,我也对迭代器调试检查等的影响感兴趣(_SECURE_SCL)

有这个代码：

template <class IIt, class OIt>
OIt copy2(IIt begin, IIt end, OIt dest)
{
   while (begin != end)
   {
      //make gap between element addresses
      for (int i = 0; i < 99999999; i++)
      {
         dest++;
      }
      *dest++ = *begin++;
   }
   return dest;
}

int main(int argc, char** argv)
{
   vector<int> vec({ 1, 2, 3 });
   vector<int> vec2;
   copy2(vec.begin(), vec.end(), back_inserter(vec2));
   for (int i : vec2)
   {
      cout << i << endl;
   }
}

编译需要很长时间，但最终会得到正确的输出

1
2
3

问题是（在不知道 的内部实现的情况下 …

可能重复:
为什么使用迭代器而不是数组索引？

string::iterator it;
for (it = str.begin(); it < str.end(); it++) 
    cout << *it;
cout << endl;

为什么不:

for (int i = 0; i < str.size(); i++)
    cout << str[i];
cout << endl;

似乎string :: iterator也没有提供范围检查.我们为什么要使用string::iterator而不是索引？

谢谢.

我在Java中有一个Hashtable,想迭代表中的所有值,并在迭代时删除一个特定的键值对.

怎么可能这样呢？

说,我有一个

std::vector<SomeClass *> v;

在我的代码中,我需要经常在程序中访问它的元素,向前和向后循环它们.

这两者之间的访问类型最快？

迭代器访问:

std::vector<SomeClass *> v;
std::vector<SomeClass *>::iterator i;
std::vector<SomeClass *>::reverse_iterator j;

// i loops forward, j loops backward
for( i = v.begin(), j = v.rbegin(); i != v.end() && j != v.rend(); i++, j++ ){
    // some operations on v items
}

下标访问(按索引)

std::vector<SomeClass *> v;
unsigned int i, j, size = v.size();

// i loops forward, j loops backward
for( i = 0, j = size - 1; i < size && j >= …

我可以检查一下next()方法,但这还够吗？有一种意识形态的方式吗？

C++ STL中有多少种类型的迭代器？截至目前,我知道这些:

• 输出迭代器
• 输入迭代器
• 转发迭代器
• 随机访问迭代器

还有更多吗？它们之间有什么区别？每个的限制和特征是什么？使用哪种类型？

在concurrent.futures.Executor.map采用可变数目从该给出的函数被调用iterables的.如果我有一个生成通常解压缩的元组的生成器,我应该如何调用它？

以下方法不起作用,因为每个生成的元组都作为map的不同参数给出:

args = ((a, b) for (a, b) in c)
for result in executor.map(f, *args):
    pass

如果没有生成器,映射的所需参数可能如下所示:

executor.map(
    f,
    (i[0] for i in args),
    (i[1] for i in args),
    ...,
    (i[N] for i in args),
)

我想Iterator在Java中实现一个与Python中的以下生成器函数类似的行为:

def iterator(array):
   for x in array:
      if x!= None:
        for y in x:
          if y!= None:
            for z in y:
              if z!= None:
                yield z

java端的x可以是多维数组或某种形式的嵌套集合.我不确定这是如何工作的.想法？

在你问之前,我已经在SO上寻找并寻找了这个,但是找不到可靠的答案.

我需要能够动态迭代具有非增量值的枚举,例如:

typedef enum {
    CAPI_SUBTYPE_NULL = 0,               /* Null subtype. */
    CAPI_SUBTYPE_DIAG_DFD = 1,           /* Data Flow diag. */
    CAPI_SUBTYPE_DIAG_ERD = 2,           /* Entity-Relationship diag. */
    CAPI_SUBTYPE_DIAG_STD = 3,           /* State Transition diag. */
    CAPI_SUBTYPE_DIAG_STC = 4,           /* Structure Chart diag. */
    CAPI_SUBTYPE_DIAG_DSD = 5,           /* Data Structure diag. */
    CAPI_SUBTYPE_SPEC_PROCESS = 6,       /* Process spec. */
    CAPI_SUBTYPE_SPEC_MODULE = 7,        /* Module spec. */
    CAPI_SUBTYPE_SPEC_TERMINATOR = 8,    /* Terminator spec. */

    CAPI_SUBTYPE_DD_ALL = …