防止迭代器失效
map扩容原理
map扩容原理Map容器是C++ STL标准库中的一种关联式容器。
Map容器类似于一个键值对的数据结构，在Map容器中，每一个键值对独立存在，各自有一个键和一个值，Map容器中的键是唯一的。
当需要在程序中根据某个唯一的键值来查找相对应的值时，Map容器就可以派上用场。
那么在Map容器中，如何实现键值对的存储和查找呢？这就需要用到Map容器的扩容机制。
Map容器中的扩容机制，是指容器在已经占用了大部分空间时，会增加更多的空间，以提供更多的存储位置。
Map容器中的扩容机制是可控的，只需要指定一个合适的容量大小，Map容器就会在需要的时候自动进行扩容操作。
Map容器的扩容机制实际上是通过重新分配内存来实现的。
当一个Map容器需要扩容时，会先分配出一个更大的内存空间，并且把原有Map容器中的所有键值对复制到新的内存空间中，然后释放掉原有的内存空间，这样就完成了Map容器的扩容操作。
Map容器的扩容机制是很重要的，因为它可以保证Map容器的高效性和可靠性。
如果Map容器没有扩容机制，那么当Map容器中的键值对超过了容器原有的大小时，就会导致键值对的插入和查找变得非常缓慢和低效，而扩容机制可以有效地避免这种情况的发生。
Map容器的扩容机制是根据容器的负载因子来触发的。
负载因子是指Map容器中键值对的数量与容器大小（即可用空间）之间的比值，当负载因子超过给定的临界比值时，就会触发Map容器的扩容操作。
负载因子的临界比值可以通过Map容器的构造函数或成员函数来指定，默认情况下，Map容器的临界比值为0.75，也就是当Map容器中的键值对数量占用容器大小的75%时，就会触发Map容器的扩容操作。
需要注意的是，Map容器的扩容操作是非常耗费时间和资源的，因此应该尽量避免频繁触发扩容操作。
可以通过合理地调整Map容器的初始大小，或者手动设置较大的预留空间来提高Map容器的效率和性能。
Map容器的扩容机制是在负载因子达到给定临界比值时自动触发的。
c++中iterator用法
c++中iterator用法详解在C++中，迭代器（Iterator）是一种用于遍历容器中元素的抽象概念。
迭代器提供了一种统一的方式来访问容器中的元素，而不需要暴露容器的内部实现细节。
不同类型的容器（如数组、链表、向量、映射等）都支持迭代器，因此你可以使用相同的代码来遍历它们。
以下是一些常见的迭代器用法详解：1. 迭代器的基本使用：```cpp#include <iostream>#include <vector>int main() {std::vector<int> numbers = {1, 2, 3, 4, 5};// 使用迭代器遍历vectorfor (std::vector<int>::iterator it = numbers.begin(); it != numbers.end(); ++it) {std::cout << *it << " ";}return 0;}```在上面的例子中，`numbers.begin()`返回指向容器起始位置的迭代器，而`numbers.end()`返回指向容器末尾的下一个位置的迭代器。
使用迭代器进行循环遍历容器。
2. auto关键字简化迭代器类型：```cpp#include <iostream>#include <vector>int main() {std::vector<int> numbers = {1, 2, 3, 4, 5};// 使用auto关键字简化迭代器类型for (auto it = numbers.begin(); it != numbers.end(); ++it) {std::cout << *it << " ";}return 0;}```使用`auto`关键字可以简化迭代器类型的声明，使代码更为简洁。
map的erase（）释放内存
map的erase（）释放内存STL中的map调⽤erase(it)，当value值为指针时，释放内存：1 #include <iostream>2 #include <map>3 #include <string>45using namespace std;6struct value{7int i;8 std::string test;9 };1011int main()12 {13 std::map<int, value*> test_map;14for(int i=0; i<10; ++i){15 value* tmp = new value();16 tmp->i = i;17 tmp->test = "test";18 test_map.insert(make_pair(i, tmp));19 }2021for(std::map<int, value*>::iterator it=test_map.begin(); it!=test_map.end();){22 std::cout << "first " << it->first << " second " << (it->second)->i <<""<< (it->second)->test << std::endl;23delete it->second;24 it->second = NULL;25 //test_map.erase(it); //迭代器失效；26 test_map.erase(it++); //防⽌迭代器失效，切记、切记27 }2829return0;30 }3132 root@u18:~/cp/test# g++ map3.cpp -g -Wall33 root@u18:~/cp/test# ls -lt a.out34 -rwxr-xr-x 1 root root 87224 Jul 911:00 a.out35 root@u18:~/cp/test# valgrind --tool=memcheck --leak-check=full ./a.out36 ==28426== Memcheck, a memory error detector37 ==28426== Copyright (C) 2002-2011, and GNU GPL'd, by Julian Seward et al.38 ==28426== Using Valgrind-3.7.0 and LibVEX; rerun with -h for copyright info39 ==28426== Command: ./a.out40 ==28426==41 first 0 second 0 test42 first 1 second 1 test43 first 2 second 2 test44 first 3 second 3 test45 first 4 second 4 test46 first 5 second 5 test47 first 6 second 6 test48 first 7 second 7 test49 first 8 second 8 test50 first 9 second 9 test51 ==28426==52 ==28426== HEAP SUMMARY:53 ==28426== in use at exit: 0 bytes in0 blocks54 ==28426== total heap usage: 30 allocs, 30 frees, 930 bytes allocated55 ==28426==56 ==28426== All heap blocks were freed -- no leaks are possible57 ==28426==58 ==28426== For counts of detected and suppressed errors, rerun with: -v59 ==28426== ERROR SUMMARY: 0 errors from0 contexts (suppressed: 2from2)。
C++ Iterator 迭代器 介绍
C++ 迭代器基础介绍迭代器提供对一个容器中的对象的访问方法，并且定义了容器中对象的范围。
迭代器就如同一个指针。
事实上，C++的指针也是一种迭代器。
但是，迭代器不仅仅是指针，因此你不能认为他们一定具有地址值。
例如，一个数组索引，也可以认为是一种迭代器。
除了使用下标来访问vector 对象的元素外，标准库还提供了另一种访问元素的方法：使用迭代器（iterator）。
迭代器是一种检查容器内元素并遍历元素的数据类型。
标准库为每一种标准容器（包括vector）定义了一种迭代器类型。
迭代器类型提供了比下标操作更通用化的方法：所有的标准库容器都定义了相应的迭代器类型，而只有少数的容器支持下标操作。
因为迭代器对所有的容器都适用，现代C++ 程序更倾向于使用迭代器而不是下标操作访问容器元素，即使对支持下标操作的vector 类型也是这样。
容器的iterator 类型每种容器类型都定义了自己的迭代器类型，如vector：vector<int>::iterator iter;这符语句定义了一个名为iter 的变量，它的数据类型是vector<int> 定义的iterator 类型。
每个标准库容器类型都定义了一个名为iterator 的成员，这里的iterator 与迭代器实际类型的含义相同。
术语：迭代器和迭代器类型程序员首次遇到有关迭代器的术语时可能会困惑不解，原因之一是由于同一个术语iterator 往往表示两个不同的事物。
一般意义上指的是迭代器的概念；而具体而言时指的则是由容器定义的具体的iterator 类型，如vector<int>。
重点要理解的是，有许多用作迭代器的类型，这些类型在概念上是相关的。
若一种类型支持一组确定的操作（这些操作可用来遍历容器内的元素，并访问这些元素的值），我们就称这种类型为迭代器。
各容器类都定义了自己的iterator 类型，用于访问容器内的元素。
C++迭代器的使用和操作总结
C++迭代器的使⽤和操作总结 迭代器是⼀种检查容器内元素并遍历元素的数据类型。
C++更趋向于使⽤迭代器⽽不是下标操作，因为标准库为每⼀种标准容器（如vector）定义了⼀种迭代器类型，⽽只⽤少数容器（如vector）⽀持下标操作访问容器元素。
⼀.定义和初始化 每种容器都定义了⾃⼰的迭代器类型，如vector:vector<int>::iterator iter; //定义⼀个名为iter的变量 每种容器都定义了⼀对名为begin和en的函数，⽤于返回迭代器。
下⾯对迭代器进⾏初始化操作：vector<int> ivec;vector<int>::iterator iter1=ivec.bengin(); //将迭代器iter1初始化为指向ivec容器的第⼀个元素vector<int>::iterator iter2=ivec.end(); //将迭代器iter2初始化为指向ivec容器的最后⼀个元素的下⼀个位置 注意end并不指向容器的任何元素，⽽是指向容器的最后元素的下⼀位置，称为超出末端迭代器。
如果vector为空，则begin返回的迭代器和end返回的迭代器相同。
⼀旦向上⾯这样定义和初始化，就相当于把该迭代器和容器进⾏了某种关联，就像把⼀个指针初始化为指向某⼀空间地址⼀样。
⼆.常⽤操作 下⾯列出了迭代器的常⽤运算操作：*iter //对iter进⾏解引⽤，返回迭代器iter指向的元素的引⽤iter->men //对iter进⾏解引⽤，获取指定元素中名为men的成员。
等效于(*iter).men++iter //给iter加1，使其指向容器的下⼀个元素iter++--iter //给iter减1，使其指向容器的前⼀个元素iter--iter1==iter2 //⽐较两个迭代器是否相等，当它们指向同⼀个容器的同⼀个元素或者都指向同同⼀个容器的超出末端的下⼀个位置时，它们相等iter1!=iter2 假设已经声明⼀个vector<int>的ivec容器，下⾯⽤迭代器来遍历ivec容器，把其每个元素重置为0：for(vector<int>::iterator iter=ivec.begin();iter!=ivec.end();++iter)*iter=0; 在C++定义的容器类型中，只有vector和queue容器提供迭代器算数运算和除!=和==之外的关系运算：iter+n //在迭代器上加（减）整数n，将产⽣指向容器中钱前⾯（后⾯）第n个元素的迭代器。
stopiteration用法 -回复
stopiteration用法 -回复StopIteration是Python中的一个内置异常类，用于标识迭代器对象已经达到了迭代的末尾。
当使用迭代器访问列表、元组、集合、字典等可迭代对象时，如果迭代器已经遍历完了所有元素，再次对其进行迭代操作时就会抛出StopIteration异常。
下面我们将详细介绍StopIteration 的用法及相关要点。
一、迭代器基础概念迭代器是Python一种用于遍历对象元素的机制。
通过迭代器，我们可以逐个访问容器中的元素，而不需要了解容器内部的具体实现细节。
Python中的可迭代对象包括列表、元组、集合、字典、字符串等。
对于这些可迭代对象，我们可以使用for循环、while循环或手动调用iter()和next()函数进行迭代操作。
1. for循环迭代pythonnumbers = [1, 2, 3, 4, 5]for number in numbers:print(number)2. while循环迭代pythonnumbers = [1, 2, 3, 4, 5]iterator = iter(numbers)while True:try:number = next(iterator)print(number)except StopIteration:break3. 手动调用iter()和next()函数进行迭代pythonnumbers = [1, 2, 3, 4, 5]iterator = iter(numbers)print(next(iterator))print(next(iterator))print(next(iterator))print(next(iterator))print(next(iterator))二、StopIteration异常的引发时机和处理方式在使用迭代器进行遍历时，当迭代器已经到达可迭代对象的末尾时，再次对其进行迭代操作就会引发StopIteration异常。
Qt中的常用容器类（解释比较全面，有插图）
Qt中的常⽤容器类（解释⽐较全⾯，有插图）在Qt库中为我们提供了⼀系列的基于模板的容器类。
这些类可以被⽤来存储特定类型的项。
例如，如果你需要⼀个⼤⼩可以变得QString数组，那么可以使⽤QVector<QString>。
这些容器类都是隐式共享的，可重⼊的，并且在速度上进⾏了优化，内存占⽤少，内联代码扩展少，从⽽可以产⽣更⼩的可执⾏⽂件。
此外，当他们被⽤作只读容器时，还是线程安全的。
对于遍历这些容器来说，可以使⽤两种类型的迭代器：Java风格的迭代器和STL风格的迭代器。
其中，Java风格的迭代器更容易使⽤，特别是对于Java⼯作⼈员来说，它提供了⾼层次的函数；然⽽，STL风格的迭代器会更⾼效，并且可以和Qt和STL的通⽤算法结合使⽤。
另外，Qt还提供了⼀个foreach关键字，使遍历容器中的每⼀项更容易了。
Qt中的容器和STL中的类似，也分为序列式容器和关联式容器。
其中，序列式容器有：QList，QLinkedList，QVector，QStack，QQueue。
对⼤部分应⽤程序来说，QList都是⼀个很好的选择。
尽管它在底层被实现为⼀个array-list，但它为我们提供了⾮常快速的添加操作，包括在头部添加和在尾部添加。
如果你确实需要⼀个linked-list，可以使⽤QLinkedList；如果你想确保你的元素占⽤连续的内存空间，可以使⽤QVector。
⽽QStack和QQueue是两个提供了LIFO和FIFO语义的⽅便类。
除了序列式容器，Qt中还提供了关联式容器：QMap，QMultiMap，QHash，QMultiHash，QSet。
这些容器中存储的都是key-value对。
其中，"Multi"容器⼜⽀持⼀个key可以关联多个value。
"Hash"容器通过使⽤⼀个hash函数⽽不是⼆分搜索提供了更快速的查找操作。
我们将这些容器类的总结在下表中：QList<T> 这是最通⽤的⼀个容器类。
set,rbegin的用法 -回复
set，rbegin的用法-回复Set和rbegin的用法Set 和rbegin 是C ++标准库中的两个关键字，通常用于处理集合数据以及反向迭代器的操作。
本文将逐步回答有关这两个关键字的用法和功能。
首先，我们需要了解集合是什么。
在编程中，集合是一个无序的元素集，每个元素在集合中只能出现一次。
C ++提供了一个名为std::set的标准容器，它实现了集合的功能。
std::set是一个模板类，需要提供元素类型作为其模板参数。
以下是创建一个整数集合的示例：cppstd::set<int> mySet;现在，我们可以使用Set的成员函数将元素插入集合中并进行其他操作。
例如，以下是将元素插入集合的示例：cppmySet.insert(5);mySet.insert(10);mySet.insert(15);请注意，插入元素时，集合会自动对元素进行排序，以便保持集合的有序性。
我们还可以使用set的成员函数来检查集合中是否存在某个元素，以及删除集合中的某个元素。
例如，以下是检查元素是否存在和删除元素的示例：cppif (mySet.count(10) > 0) {std::cout << "Element 10 is present in the set" << std::endl;}mySet.erase(15);现在，对于rbegin关键字，它是通过集合的成员函数rbegin()来使用的，返回一个指向集合最后一个元素的反向迭代器。
反向迭代器的用途是逆序访问集合元素。
以下是使用rbegin关键字逆序访问集合元素的示例：cppstd::set<int>::reverse_iterator rit;for (rit = mySet.rbegin(); rit != mySet.rend(); ++rit) {std::cout << *rit << std::endl;}在上面的示例中，我们首先创建一个reverse_iterator对象rit，并通过rbegin()函数初始化它。
qlist迭代器原理
QList和迭代器的基本原理QList是Qt框架中的一个容器类，用于存储和操作一组相同类型的元素。
它是一个动态数组，可以根据需要自动调整大小。
QList提供了一组丰富的成员函数，以便对元素进行添加、删除、查找、排序等操作。
迭代器是一种用于遍历容器中元素的工具。
它提供了一组接口，允许我们在不了解容器内部实现细节的情况下，依次访问容器中的元素。
QList迭代器是一种特殊类型的迭代器，用于遍历QList中的元素。
QList的实现原理QList内部使用一个动态分配的数组来存储元素，这个数组被称为buffer。
buffer 是一个指针数组，每个指针指向一个元素。
当QList的容量不足以存放新的元素时，QList会自动扩容，分配一个更大的buffer，并将原有的元素拷贝到新的buffer 中。
为了支持高效的随机访问，QList还维护了一个指向buffer的指针data，以及一个整数size表示元素的个数。
通过data指针和size，我们可以快速访问QList中的元素，而不需要遍历整个容器。
QList还提供了一些成员函数，用于对元素进行添加、删除、查找等操作。
这些函数会根据需要调整buffer的大小，并维护data和size的正确值。
QList迭代器的实现原理QList迭代器是一个用于遍历QList元素的对象。
它包含一个指向当前元素的指针，以及一些用于遍历的操作函数。
QList迭代器的定义如下：class iterator{public:iterator(T* p); // 构造函数iterator(const iterator& other); // 拷贝构造函数iterator& operator=(const iterator& other); // 赋值运算符bool operator==(const iterator& other) const; // 相等运算符bool operator!=(const iterator& other) const; // 不等运算符T& operator*(); // 解引用运算符iterator& operator++(); // 前置自增运算符iterator operator++(int); // 后置自增运算符iterator& operator--(); // 前置自减运算符iterator operator--(int); // 后置自减运算符};QList迭代器的构造函数会将指针指向QList的第一个元素。
QVector使用心得（2014415）
QVector使用心得（2014415）标准库Vector类型使用需要的头文件：#include <vector>Vector：Vector 是一个类模板。
不是一种数据类型。
Vector<int>是一种数据类型。
一、定义和初始化Vector<T> v1; //默认构造函数v1为空Vector<T> v2(v1);//v2是v1的一个副本Vector<T> v3(n,i);//v3包含n个值为i的元素Vector<T> v4(n); //v4含有n个值为0的元素二、值初始化1> 如果没有指定元素初始化式，标准库自行提供一个初始化值进行值初始化。
2> 如果保存的式含有构造函数的类类型的元素，标准库使用该类型的构造函数初始化。
3> 如果保存的式没有构造函数的类类型的元素，标准库产生一个带初始值的对象，使用这个对象进行值初始化。
三、Vector对象最重要的几种操作1. v.push_back(t) 在数组的最后添加一个值为t的数据2. v.size() 当前使用数据的大小3. v.empty() 判断vector是否为空4. v[n] 返回v中位置为n的元素5. v1=v2 把v1的元素替换为v2元素的副本6. v1==v2 判断v1与v2是否相等7. ！=、<、<=、>、>= 保持这些操作符惯有含义vector容器类型vector容器是一个模板类，可以存放任何类型的对象（但必须是同一类对象）。
vector对象可以在运行时高效地添加元素，并且vector中元素是连续存储的。
vector的构造函数原型：template<typename T>explicit vector(); // 默认构造函数，vector对象为空explicit vector(size_type n, const T& v = T()); // 创建有n个元素的vector对象vector(const vector& x);vector(const_iterator first, const_iterator last);注：vector容器内存放的所有对象都是经过初始化的。
关于STL的erase（）陷阱-迭代器失效问题的总结
关于STL的erase（）陷阱-迭代器失效问题的总结下⾯材料整理⾃Internet&著作。
STL中的容器按存储⽅式分为两类，⼀类是按以数组形式存储的容器（如：vector 、deque)；另⼀类是以不连续的节点形式存储的容器（如：list、set、map）。
在使⽤erase⽅法来删除元素时，需要注意⼀些问题。
1.list,set,map容器在使⽤ list、set 或 map遍历删除某些元素时可以这样使⽤：1.1 正确写法1std::list< int> List;std::list< int>::iterator itList;for( itList = List.begin(); itList != List.end(); ){if( WillDelete( *itList) ){itList = List.erase( itList);}elseitList++;}1.2 正确写法2std::list< int> List;std::list< int>::iterator itList;for( itList = List.begin(); itList != List.end(); ){if( WillDelete( *itList) ){List.erase( itList++);}elseitList++;}1.3 错误写法1std::list< int> List;std::list< int>::iterator itList;for( itList = List.begin(); itList != List.end(); itList++){if( WillDelete( *itList) ){List.erase( itList);}}1.4 错误写法2std::list< int> List;std::list< int>::iterator itList;for( itList = List.begin(); itList != List.end(); ){if( WillDelete( *itList) ){itList = List.erase( ++itList);}elseitList++;}1.5 分析正确使⽤⽅法1：通过erase⽅法的返回值来获取下⼀个元素的位置正确使⽤⽅法2：在调⽤erase⽅法之前先使⽤ “++”来获取下⼀个元素的位置错误使⽤⽅法1：在调⽤erase⽅法之后使⽤“++”来获取下⼀个元素的位置，由于在调⽤erase⽅法以后，该元素的位置已经被删除，如果在根据这个旧的位置来获取下⼀个位置，则会出现异常。
STL map 内存改变,迭代器失效,_Isnil(_Ptr)和红黑树
STL map 内存改变，迭代器失效，_Isnil(_Ptr)和红黑树最近在做项目时发现一个crash的问题，当时得到的dmp文件显示crash在一个以map为循环变量的循环中，crash位置在如下的代码中标出。
void _Inc(){ // move to node with next larger value#if _HAS_ITERATOR_DEBUGGINGif (this->_Mycont == 0|| _Ptr == 0|| _Isnil(_Ptr)){_DEBUG_ERROR("map/set iterator not incrementable");_SCL_SECURE_OUT_OF_RANGE;}#else_SCL_SECURE_VALIDATE(this->_Has_container());if (_Isnil(_Ptr))---------------------------------------->Why crash here?{_SCL_SECURE_OUT_OF_RANGE;// end() shouldn't be incremented, don't move if _SCL_SECURE is not turned on}#endif /* _HAS_ITERATOR_DEBUGGING */else if (!_Isnil(_Right(_Ptr)))_Ptr = _Min(_Right(_Ptr)); // ==> smallest of right subtreeelse{ // climb looking for right subtree_Nodeptr _Pnode;while (!_Isnil(_Pnode = _Parent(_Ptr))&& _Ptr == _Right(_Pnode))_Ptr = _Pnode; // ==> parent while right subtree_Ptr = _Pnode; // ==> parent (head if end())}}这是C++ 中红黑树迭代器的标准实现，那从这个栈帧能说明我们的代码哪出问题了么？在阅读红黑树的实现代码中有一条语句困扰了我大约半个小时的时间，这条语句就是：_Isnil(_Ptr)标准实现中到处都是这条语句，2年前算法导论系统的学习过一遍，但是由于长时间没有相关的功能需要用到这么深入的知识，有些具体的问题已经记得不是很清楚，于是为了弄对这条语句以及对红黑树有透测的理解，再一次对红黑树知识进行了系统的学习，并翻阅了一些资料，为了使本文自成体系，下面对基础知识进行一些说明。
C++STLvector扩容原理分析
C++STLvector扩容原理分析扩容特点： 1）新增元素：vector通过⼀个连续的数组存放元素，如果集合已满，在新增数据的时候，就要分配⼀块更⼤的内存，将原来的数据复制过来，释放之前的内存，在插⼊新增的元素； 2）对vector的任何操作，⼀旦引起空间重新配置，指向原vector的所有迭代器就都失效了 ； 3）初始时刻vector的capacity为0，插⼊第⼀个元素后capacity增加为1； 4）不同的编译器实现的扩容⽅式不⼀样，VS2015中以1.5倍扩容，GCC以2倍扩容。
以成倍⽅式增长 假定有 n 个元素，倍增因⼦为 m； 完成这 n 个元素往⼀个 vector 中的 push_back操作，需要重新分配内存的次数⼤约为 logm(n)； 第 i 次重新分配将会导致复制 m^(i) (也就是当前的vector.size() ⼤⼩)个旧空间中元素； n 次 push_back 操作所花费的时间复制度为O(n): m / (m - 1)，这是⼀个常量，均摊分析的⽅法可知，vector 中 push_back 操作的时间复杂度为常量时间。
⼀次增加固定值⼤⼩ 假定有 n 个元素,每次增加k个； 第i次增加复制的数量为为：100i n 次 push_back 操作所花费的时间复杂度为O(n^2): 均摊下来每次push_back 操作的时间复杂度为O(n)。
总结：对⽐可以发现采⽤采⽤成倍⽅式扩容，可以保证常数的时间复杂度，⽽增加指定⼤⼩的容量只能达到O(n)的时间复杂度，因此，使⽤成倍的⽅式扩容。
增长因⼦的选取： 根据查阅的资料显⽰，考虑可能产⽣的堆空间浪费，成倍增长倍数不能太⼤，使⽤较为⼴泛的扩容⽅式有两种，以2⼆倍的⽅式扩容，或者以1.5倍的⽅式扩容。
以2倍的⽅式扩容，导致下⼀次申请的内存必然⼤于之前分配内存的总和，导致之前分配的内存不能再被使⽤，所以最好倍增长因⼦设置为(1,2)之间。
for循环、增强for循环和迭代器的区别
for循环、增强for循环和迭代器的区别1、迭代器是⽤于⽅便集合遍历的，实现了Iterable接⼝的集合都可以使⽤迭代器来遍历。
使⽤迭代器遍历元素时，除了查看之外，只能做remove操作。
2、增强for循环，内部使⽤的是迭代器，所以它的操作对象是数组和可以使⽤迭代器的集合。
遍历时只能查看，⽆法修改、删除、增加。
所以如果需要对遍历的对象做增删修改的操作，使⽤普通的for循环来操作。
迭代器/增强for循环@Testpublic void test003(){List<Integer> list = new ArrayList<>();list.add(22);list.add(242);list.add(232);list.add(212);iteratorApply(list);forApple(list);}//迭代器public void iteratorApply(List<Integer> list){Iterator<Integer> it = list.iterator();while (it.hasNext()){int num = it.next();System.out.println(num);if (num == 22){it.remove();}}System.out.println(list.size());}//增强for循环public void forApple(List<Integer> list){for (int num : list){System.out.println(num);}}。
C++迭代器失效的几种情况总结
C++迭代器失效的⼏种情况总结⼀、序列式容器(数组式容器)对于序列式容器(如vector,deque)，序列式容器就是数组式容器，删除当前的iterator会使后⾯所有元素的iterator都失效。
这是因为vetor,deque使⽤了连续分配的内存，删除⼀个元素导致后⾯所有的元素会向前移动⼀个位置。
所以不能使⽤erase(iter++)的⽅式，还好erase⽅法可以返回下⼀个有效的iterator。
1for (iter = cont.begin(); iter != cont.end();)2 {3 (*it)->doSomething();4if (shouldDelete(*iter))5 iter = cont.erase(iter); //erase删除元素，返回下⼀个迭代器6else7 ++iter;8 }迭代器失效：1void vectorTest()2 {3 vector<int> container;4for (int i = 0; i < 10; i++)5 {6 container.push_back(i);7 }89 vector<int>::iterator iter;10for (iter = container.begin(); iter != container.end(); iter++)11 {12if (*iter > 3)13 container.erase(iter);14 }1516for (iter = container.begin(); iter != container.end(); iter++)17 {18 cout<<*iter<<endl;19 }20 }报错是：vectoriterator not incrementable.迭代器在执⾏++操作时报错！已经失效的迭代器不能再进⾏⾃增运算了。
多益笔试题——精选推荐
智力题每题10分，很凶险题目一：有20张上下表面光滑的扑克牌，其中有8张向上，要求你闭着眼睛且不借助任何工具把这20张扑克牌分成两堆，使得每堆向上的扑克牌的数目一样多。
解决方法：从20张扑克牌中拿出8张，并把8张扑克牌翻过来，这样两堆扑克牌向上的扑克牌数目就一样多了。
证明：假如从20张扑克牌抽出的8张中有N张向上的扑克牌（N>=0&&N<=8）翻过来后有8-N张向上的扑克牌，因为总共只有8张向上的扑克牌，被抽出N张向上扑克牌后，剩下8-N张向上的扑克牌，故另一堆向上的扑克牌数为8-N;由此证明两堆向上的扑克牌数一样多。
题目二：把一个钝角三角形如何切割成最少数量的锐角三角形？解决方法：作三角形的角平分线交于一点（内心），以内心到钝角的点为半径画圆，然后连接圆心与交点，相邻的交点也相连，这样就可得到7个锐角三角形。
1.不用第三个变量，写swap函数，交换两个变量的值。
2.几个sizeof，包括指针，数组，malloc出的堆空间，通过函数传递的数组形参，结构体3.考了两个stl，一个序列容器找错的，一个map容器写输出结果的序列容器的错误是迭代器失效，map容器考的很简单4.struct {int a;char b;long c;short d;short e[5];}*p;p=0x1000000;p+0x200=?(unsigned long*)p+0x200=?(unsigned char*)p+0x200=?5.改错char c[5],*p;int array[100];int **p;//改为int (*p)[5]p = &array;6.写出输出#include <iostream>using namespace std;//函数功能：判断i的二进制表示中1的个数int fun1(){int i = 5;//原题不是15，貌似是1000int num = 0;while (i != 0){i = i & (i - 1);num++;}return num;}//无论i是多少，都返回2int fun2(){int i = 15;int num = 0;while (i != 0){i = i && (i - 1);num++;}return num;}int main(){cout << fun1() << endl<< fun2() << endl;return 0;}7.其他题目很简单，没有数据库，没有复杂算法（第二轮笔试有算法，我的资源有下载）最后祝福各位都能找到好工作~~！o(∩_∩)o文案编辑词条B 添加义项?文案，原指放书的桌子，后来指在桌子上写字的人。
primer笔记
1、非const变量默认为extern ，const对象要使别的文件中访问，必须显示的指定他为extern2、引用主要用于形参别名3、Constint a =1; int&b =a; 出错4、非const引用只能绑定到与该引用同类型的对象const引用可以绑定到不同但相关的类型的对象或者绑定到右值cons tint&a = 1;正确5、枚举类型的写法很不熟悉Enum forms {shape = 2, sphere, cylinder = 3, polygon};Forms fo = shape;每一个枚举成员都是一种新的唯一的类型，不能用他们初始化时的数字替代Forms fo = 2；出错第一个默认初始化为06、每个类都定义了一个接口和一个实现。
接口即所提供的操作，实现包括该类所需要的数据。
7、#ifndef #define #endif自己的头文件用引号里面.h 标准头文件用<>没有.h第三章标准库类型1、While(cin>> string)Cout<< string;会根据空格来分词依次读取字符串输入空格空格hello空格world 会输出helloworld2、string直接初始化复制初始化构造函数3、getline(cin, string) 空格空格hello空格world 会输出空格空格hello空格world 换行会输出换行4、string::size_type是string类的成员跟std有本质区别5、cout vector的【i】不能直接输出整个vector6、vector<int> ivec(10);默认的十个数是十个07、vector<int>::const_iteratoriter只能iter++ 不能改变*iterconst vector<int>::iterator iter限定iter只指向这个vector元素不能动可以改变*iter不能iter++8、vector[j++] = j 与a[i++] = I不同？？？9、Sighed 类型的代表n的difference_type10、Bitset<n> b; 很奇怪11、可以cout b12、Pow (double,int)<cmath>13、Bitset不够按原顺序在左边添零14、c++ Primer bitset操作中os<<b 什么意思？书上说是把b中的位集输出到os流。
stopiteration用法 -回复
stopiteration用法-回复标题：Python中的StopIteration用法详解在Python编程中，我们经常需要处理一些可迭代的对象，如列表、元组、字符串等。
在遍历这些对象的过程中，如果遇到某个条件或满足某个终止条件时，我们就希望停止迭代过程。
这时，我们就需要用到Python中的一个特殊异常——StopIteration。
一、StopIteration的定义StopIteration是一个内置的异常类，通常用于控制迭代器的行为。
当迭代器没有更多的值可以返回时，就会引发这个异常。
换句话说，当我们调用迭代器的next()方法时，如果没有更多的元素可供迭代，则会抛出StopIteration异常。
二、StopIteration的应用场景1. 自定义迭代器自定义迭代器是StopIteration最常见的应用场景。
当我们需要创建一个自己的迭代器类时，就需要在适当的时机抛出StopIteration异常，以告知调用者迭代已经结束。
例如，我们可以创建一个简单的计数器类，它从0开始计数，每次调用next()方法时，就返回下一个整数。
当计数超过指定的最大值时，就抛出StopIteration异常。
pythonclass Counter:def __init__(self, max_value):self.max_value = max_valueself.current = 0def __iter__(self):return selfdef __next__(self):if self.current >= self.max_value:raise StopIterationelse:self.current += 1return self.current - 12. 在生成器函数中使用生成器函数是一种特殊的函数，它可以返回一个生成器对象，而不需要显式地创建迭代器类。
生成器函数内部使用yield语句来返回值，并且可以在下次调用时继续执行。
最全Vector用法总结
最全Vector用法总结C++内置的数组支持容器的机制，但是它不支持容器抽象的语义。
要解决此问题我们自己实现这样的类。
在标准C++中，用容器向量（vector）实现。
容器向量也是一个类模板。
标准库vector类型使用需要的头文件：#include <vector>。
vector 是一个类模板。
不是一种数据类型，vector<int>是一种数据类型。
V ector的存储空间是连续的,list不是连续存储的。
一、定义和初始化vector< typeName > v1; //默认v1为空，故下面的赋值是错误的v1[0]=5;vector<typeName>v2(v1); 或v2=v1;或vector<typeName> v2(v1.begin(), v1.end());//v2是v1的一个副本，若v1.size（）>v2.size()则赋值后v2.size()被扩充为v1.size()。
vector< typeName > v3(n,i);//v3包含n个值为i的typeName类型元素vector< typeName > v4(n); //v4含有n个值为0的元素int a[4]={0,1,2,3,3}; vector<int> v5(a,a+5);//v5的size为5，v5被初始化为a的5个值。
后一个指针要指向将被拷贝的末元素的下一位置。
vector<int> v6(v5);//v6是v5的拷贝vector< 类型> 标识符（最大容量，初始所有值）；二、值初始化1> 如果没有指定元素初始化式，标准库自行提供一个初始化值进行值初始化。
2> 如果保存的式含有构造函数的类类型的元素，标准库使用该类型的构造函数初始化。
3> 如果保存的式没有构造函数的类类型的元素，标准库产生一个带初始值的对象，使用这个对象进行值初始化。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
{
++iter;
}
}
list容器删除元素方法如下：
// 第一种方法
iter = lst.erase(iter);
//第二种方法
lst.erase(iter++);
原因：list容器是顺序容器的一种，所以erase函数会返回下一个有效地迭代器，但因为是链式存储所以数据不会向前移动，所以iter = lst.erase(iter)和lst.erase(iter++)两种方法均可用
1、顺序容器（如：vector，string，deque）使用erase()方法：
erase函数原型：iterator erase(const_iterator iter);
顺序容器的erase函数都会返回下一个有效地迭代器，可以这样使用：iter = vec.erase(iter)；但以数组形式存的顺序容器（不包括list）不能这样使用：vec.erase(iter++)，因为该类型容器一旦erase时，iter++操作会在删除前使iter指向下一个位置，同时后面的数据会向前面移动一个位置，所以iter实际指向的已经不是所期望的内容了。
}
2、关联容器（如：set，map）使用erase()方法：
erase函数原型：void erase(const_iterator iter);
关联容器的erase函数都会返回void或被删除个数(与这里讨论的内容无关)，可以这样使用：iter = vec.erase(iter++)。
set容器删除元素方法如下：
vector容器删除元素方法如下：
for (vector<T>::const_iterator iter=vec.begin(); iter!=vec.end();)
{
if (WillDelete(*iter))
{
iter = vec.erase(iter);
}
项目中用到了std::list容器，删除容器中元素后即调用erase()函数后可能会导致迭代器失效。
一般导致迭代器失效的原因有两种：
1、迭代器对象已经变成了“野指针”，对其进行*,++,--都会引起程序内存操作异常。
2、迭代器对象所指向的内容已经不是所期望的内容。
STL中的容器按存储方式分为两类，一类是顺序容器（如：vector，string，deque和list），一类是关联容器（如：set，map），使用erase()函数时不同。（注意：以下所说的是C++98标准，C++11标准erase函数有变动）
for (set<T>::const_iterator iter=s.begin(); iter!=s.end();)
{
if (WillDelete(*iter))
{
s.erase(iter++);
}
else
{
++i