STL vector小结
stl常用函数
stl常用函数STL（StandardTemplateLibrary）是C++标准库中的一个重要部分，它提供了许多常用的数据结构和算法，方便了程序员的开发工作。
在STL中，有许多常用的函数，本文将介绍一些常用的STL函数。
1. vectorvector是STL中最常用的容器之一，它是一个动态数组，可以方便地进行插入、删除等操作。
下面是一些常用的vector函数：1.1 push_backpush_back函数用于在vector的末尾添加一个元素，例如：```c++vector<int> vec;vec.push_back(1);vec.push_back(2);vec.push_back(3);```这样，vec中就包含了1、2、3这三个元素。
1.2 pop_backpop_back函数用于删除vector末尾的一个元素，例如：```c++vector<int> vec;vec.push_back(1);vec.push_back(2);vec.push_back(3);vec.pop_back();```这样，vec中就只包含了1、2这两个元素。
1.3 sizesize函数用于返回vector中元素的个数，例如： ```c++vector<int> vec;vec.push_back(1);vec.push_back(2);vec.push_back(3);cout << vec.size() << endl;```输出结果为3。
1.4 clearclear函数用于清空vector中的所有元素，例如： ```c++vector<int> vec;vec.push_back(1);vec.push_back(2);vec.push_back(3);vec.clear();```这样，vec就不包含任何元素了。
2. listlist是STL中另一个常用的容器，它是一个双向链表，可以方便地进行插入、删除等操作。
作业一：vector实验
安徽财经大学实验报告
班级：学号：姓名: 实验成绩：
课程名称：stl和boost类库实验实验名称：vector类
实验地点:信息管理实验室日期: 4-14 时间: 19:00~20:30 教师：张林
说明：
1）实验原理简单介绍一下，不要超过300字。
2）姓名需要手签，成绩不要填写，其他如班级、学号、日期、时间可以机打。
3）实验内容包括多道题目。
如果题目较多，可以直接复制题目格式
4）每道题目包括：题目及目的、题目的描述、程序源代码、程序编译信息、测试结果与分析、题目小结等部分。
5）如果实验已经给出了源代码，可以不写。
如果你认为源代码存在问题，也可以写出指正。
源代码的核心部分，要给与注释。
6）如果有好的想法，一道题的源代码可以出现多份。
7）如果有的实验，我们只需要编译，修改程序的错误。
则需要程序编译，否则此栏可以删掉。
此栏需要复制出错误的信息（只复制错误信息的主要部分），同时给出错误的原因和修改方案。
8）如果程序有运行结果，则需要测试结果与分析；否则，可以删掉。
测试结果需要写入输入数据、输出数据和简单分析。
9）实验报告需要打印上交。
打印时，请把本说明删掉。
详解C++STLvector容量（capacity）和大小（size）的区别
详解C++STLvector容量（capacity）和⼤⼩（size）的区别很多初学者分不清楚 vector 容器的容量（capacity）和⼤⼩（size）之间的区别，甚⾄有⼈认为它们表达的是⼀个意思。
本节将对 vector 容量和⼤⼩各⾃的含义做⼀个详细的介绍。
vector 容器的容量（⽤ capacity 表⽰），指的是在不分配更多内存的情况下，容器可以保存的最多元素个数；⽽ vector 容器的⼤⼩（⽤ size 表⽰），指的是它实际所包含的元素个数。
对于⼀个 vector 对象来说，通过该模板类提供的 capacity() 成员函数，可以获得当前容器的容量；通过 size() 成员函数，可以获得容器当前的⼤⼩。
例如：#include <iostream>#include <vector>using namespace std;int main(){std::vector<int>value{ 2,3,5,7,11,13,17,19,23,29,31,37,41,43,47 };value.reserve(20);cout << "value 容量是：" << value.capacity() << endl;cout << "value ⼤⼩是：" << value.size() << endl;return 0;}程序输出结果为：value 容量是：20value ⼤⼩是：15结合该程序的输出结果，图 1 可以更好的说明 vector 容器容量和⼤⼩之间的关系。
图 1 vector 容量和⼤⼩的区别显然，vector 容器的⼤⼩不能超出它的容量，在⼤⼩等于容量的基础上，只要增加⼀个元素，就必须分配更多的内存。
注意，这⾥的“更多”并不是 1 个。
c++向量的用法
c++向量的用法C++中的向量（Vector）是一种动态数组，它能够自动调整大小以适应不同的元素数量。
向量属于标准模板库（Standard Template Library，STL）的一部分，它提供了许多方便的函数和操作符，用于方便地处理和操作元素。
下面将介绍向量的用法及相关参考内容。
1. 定义和初始化向量向量的定义需要包含<vector>头文件，并使用std命名空间。
我们可以使用以下方式来定义和初始化向量：```cpp#include <vector>#include <iostream>int main() {// 定义一个整数类型的向量std::vector<int> v1;// 定义一个浮点类型的向量，初始容量为10std::vector<float> v2(10);// 定义一个字符串类型的向量，并初始化为{"Hello", "World"}std::vector<std::string> v3{"Hello", "World"};// 定义一个空向量，并指定初始容量为5std::vector<char> v4(5, 'a');// 输出向量中的元素for (int i : v1) {std::cout << i << " ";}std::cout << std::endl;for (float f : v2) {std::cout << f << " ";}std::cout << std::endl;for (std::string str : v3) {std::cout << str << " ";}std::cout << std::endl;for (char c : v4) {std::cout << c << " ";}std::cout << std::endl;return 0;}```参考内容：- 《C++ Primer Plus》- 《C++标准库-深度剖析》，侯捷- 《C++标准库速查表》2. 向向量中添加元素向量提供了几个函数来添加元素：- push_back(value)：在向量的末尾添加一个元素；- insert(iterator, value)：在指定位置插入一个元素；- emplace(iterator, args...)：在指定位置使用参数构造一个元素；- insert(iterator, n, value)：在指定位置插入n个元素；- insert(iterator, first, last)：在指定位置插入另一个区间内的元素。
stl中vector用法
stl中vector用法《stl中vector用法》vector在STL里就像一个超级灵活的收纳盒。
它可以用来存放各种各样的数据，不管是整数、小数，还是自定义的结构体之类的东西，只要你想把一堆数据放在一起管理，vector就可能是个很棒的选择。
比如说你要记录一群人的年龄。
你可以创建一个vector来存放这些年龄数据。
在C++里，创建一个vector很简单，就像你准备一个新的收纳盒一样。
你可以这样写：`vector<int> ages;`，这里的`<int>`就表示这个vector是用来存放整数类型的数据的，也就是我们的年龄。
要是你想一开始就给这个vector里放几个年龄数据，也可以这么干：`vector<int> ages = {18, 20, 25};`，这就好比你在收纳盒一拿过来的时候就往里面放了几件东西。
往vector里添加数据就像是往收纳盒里放东西。
你可以用`push_back`这个方法。
比如说又知道了一个人的年龄是30岁，那就可以这样把这个年龄放到我们的ages这个vector里：`ages.push_back(30);`。
这就跟你从旁边拿起一件东西，然后轻松地放到收纳盒里一样自然。
那怎么把vector里的数据取出来呢？这也不难。
你可以像从收纳盒里拿东西一样，用索引的方式。
就好比收纳盒里的东西是按顺序放着的，vector里的数据也是有顺序的。
如果想拿到刚刚放进去的30岁这个年龄数据，你可以这么做：`int theAge = ages[ages.size() - 1];`。
这里`ages.size()`就是vector里数据的个数，因为索引是从0开始的，所以要减1才能拿到最后放进去的那个数据。
vector还有个好玩的地方，它的大小是可以动态变化的。
就像你的收纳盒是有弹性的一样，如果又有新的年龄数据要放进去，vector会自动调整自己的大小来容纳新的数据。
STL标准模板库向量容器（vector）
STL标准模板库向量容器（vector）向量容器使⽤动态数组存储、管理对象。
因为数组是⼀个随机访问数据结构，所以可以随机访问向量中的元素。
在数组中间或是开始处插⼊⼀个元素是费时的，特别是在数组⾮常⼤的时候更是如此。
然⽽在数组末端插⼊元素却很快。
实现向量容器的类名是vector（容器是类模板）。
包含vector类的头⽂件名是vector。
所以，如果要在程序⾥使⽤向量容器，就要在程序中包含下⾯语句：#include <vector>此外，在定义向量类型对象时，必须指定该对象的类型，因为vector类是⼀个类模板。
例如，语句：vector<int> intList;将intList声明为⼀个元素类型为int的向量容器对象。
类似地，语句：vector<string> stringList;将stringList声明为⼀个元素类型为string的向量容器对象。
声明向量对象vector类包含了多个构造函数，其中包括默认构造函数。
因此，可以通过多种⽅式来声明和初始化向量容器。
表⼀描述了怎样声明和初始化指定类型的向量容器。
表⼀各种声明和初始向量容器的⽅法语句作⽤vector<elementType> vecList; 创建⼀个没有任何元素的空向量vecList（使⽤默认构造函数）vector<elementType> vecList(otherVecList)创建⼀个向量vecList，并使⽤向量otherVecList中的元素初始化该向量。
向量vecList与向量otherVecList的类型相同vector<elementType> vecLIst(size);创建⼀个⼤⼩为size的向量vecList，并使⽤默认构造函数初始化该向量 vector<elementType>vecList(n,elem);创建⼀个⼤⼩为n的向量vecList，该向量中所有的n个元素都初始化为elemvector<elementType> vecList(begin,end);创建⼀个向量vecList，并初始化该向量（begin,end）中的元素。
STL容器简介
STL容器简介stl不是⾯向对象的编程，⽽是⼀种不同的编程模式————泛型编程我们常⽤到的STL容器有vector、list、deque、map、multimap、set、multiset顺序性容器：vector、deque、list关联性容器：set、multiset、map、multimap容器适配器：stack、queueverctor vector类似于动态数组，直接访问元素，从后⾯快速插⼊或者删除； vector类似于C语⾔中的数组，它维护⼀段连续的内存空间，具有固定的起始地址，因⽽能⾮常⽅便地进⾏随机存取，即 [] 操作符，但因为它的内存区域是连续的，所以在它中间插⼊或删除某个元素，需要复制并移动现有的元素。
此外，当被插⼊的内存空间不够时，需要重新申请⼀块⾜够⼤的内存并进⾏内存拷贝。
值得注意的是，vector每次扩容为原来的两倍，对⼩对象来说执⾏效率⾼，但如果遇到⼤对象，执⾏效率就低了。
list 可以从任何地⽅插⼊或者删除； 类似于C语⾔中的双向链表，它通过指针来进⾏数据的访问，因此维护的内存空间可以不连续，这也⾮常有利于数据的随机存取，因⽽它没有提供 [] 操作符重载；deque 是⼀个double-ended queue 1)⽀持随即存取，也就是[]操作符， 2)⽀持两端操作，push(pop)-back(front)，在两端操作上与list效率差不多stack 1)可⽤ vector, list, deque来实现 2)缺省情况下，⽤deque实现 template<classT, class Cont = deque<T> > class stack { ….. }； 3)⽤ vector和deque实现，⽐⽤list实现性能好 4)stack是后进先出的数据结构， 5)只能插⼊、删除、访问栈顶的元素的操作: push: 插⼊元素pop: 弹出元素 top: 返回栈顶元素的引⽤map map类似于数据库中的１:１关系，它是⼀种关联容器，提供⼀对⼀(C++ primer中⽂版中将第⼀个译为键，每个键只能在map中出现⼀次，第⼆个被译为该键对应的值)的数据处理能⼒，这种特性了使得map类似于数据结构⾥的红⿊⼆叉树。
C++STL中的vector的内存分配与释放
C++STL中的vector的内存分配与释放1.vector的内存增长vector其中⼀个特点：内存空间只会增长，不会减⼩，援引C++ Primer：为了⽀持快速的随机访问，vector容器的元素以连续⽅式存放，每⼀个元素都紧挨着前⼀个元素存储。
设想⼀下，当vector添加⼀个元素时，为了满⾜连续存放这个特性，都需要重新分配空间、拷贝元素、撤销旧空间，这样性能难以接受。
因此STL实现者在对vector进⾏内存分配时，其实际分配的容量要⽐当前所需的空间多⼀些。
就是说，vector 容器预留了⼀些额外的存储区，⽤于存放新添加的元素，这样就不必为每个新元素重新分配整个容器的内存空间。
在调⽤push_back时，每次执⾏push_back操作，相当于底层的数组实现要重新分配⼤⼩；这种实现体现到vector实现就是每当push_back ⼀个元素,都要重新分配⼀个⼤⼀个元素的存储，然后将原来的元素拷贝到新的存储，之后在拷贝push_back的元素，最后要析构原有的vector并释放原有的内存。
例如下⾯程序：#include <iostream>#include <cstdlib>#include <vector>using namespace std;class Point{public:Point(){cout << "construction" << endl;}Point(const Point& p){cout << "copy construction" << endl;}~Point(){cout << "destruction" << endl;}};int main(){vector<Point> pointVec;Point a;Point b;pointVec.push_back(a);pointVec.push_back(b);cout<<pointVec.size()<<std::endl;return0;}输出结果：其中执⾏pointVec.push_back(a);此时vector会申请⼀个内存空间，并调⽤拷贝构造函数将a放到vector中再调⽤pointVec.push_back(b);此时内存不够需要扩⼤内存，重新分配内存这时再调⽤拷贝构造函数将a拷贝到新的内存，再将b拷⼊新的内存，同时有⼈调⽤Point拷贝构造函数，最后释放原来的内存此时调⽤Point的析构函数。
stl vector用法erase
stl vector用法eraseSTL vector的erase函数用于在容器中删除元素。
它有两种形式：1. `void erase (iterator position)`：删除给定位置的元素，并返回指向被删除元素之后位置的迭代器。
2. `iterator erase (iterator first, iterator last)`：删除位于[first,last)范围内的元素，并返回指向被删除元素之后位置的迭代器。
使用erase函数的示例代码如下：```cpp#include <iostream>#include <vector>int main() {std::vector<int> vec = {1, 2, 3, 4, 5};// 删除第三个元素vec.erase(vec.begin() + 2);// 输出: 1 2 4 5for (auto it = vec.begin(); it != vec.end(); ++it) {std::cout << *it << " ";}std::cout << std::endl;// 删除第二个和第三个元素vec.erase(vec.begin() + 1, vec.begin() + 3);// 输出: 1 5for (auto it = vec.begin(); it != vec.end(); ++it) {std::cout << *it << " ";}return 0;}```在以上示例中，我们使用`vec.erase(vec.begin() + 2)`删除了第三个元素，并使用`vec.erase(vec.begin() + 1, vec.begin() + 3)`删除了第二个和第三个元素。
最后，我们通过循环输出vector中的剩余元素。
stl容器知识点总结
stl容器知识点总结一、STL容器的种类STL中的容器主要分为序列式容器（Sequence Containers）和关联式容器（Associative Containers）两大类。
序列式容器包括vector、deque、list、forward_list以及array等，而关联式容器则包括set、map、multiset、multimap和unordered_set、unordered_map、unordered_multiset、unordered_multimap等。
1. 序列式容器（1）vector：动态数组，支持随机存取，可以在尾部进行快速插入和删除操作，但在中间和头部的插入和删除效率比较低。
（2）deque：双端队列，支持随机存取，同时在头部和尾部进行快速插入和删除操作，但在中间的插入和删除效率比较低。
（3）list：双向链表，支持在任意位置进行快速插入和删除操作，但不支持随机存取。
（4）forward_list：单向链表，与list相似，但只支持单向的迭代器访问。
（5）array：固定大小的数组，提供与普通数组相似的访问和操作方式。
2. 关联式容器（1）set：集合，不允许重复的元素，并且会自动排序。
（2）map：映射，每个元素都含有一个键值对，并且键是唯一的，自动排序。
（3）multiset：多重集合，允许重复的元素，并且会自动排序。
（4）multimap：多重映射，允许重复的键值对，并且会自动排序。
（5）unordered_set：无序集合，不允许重复的元素，内部实现采用哈希表。
（6）unordered_map：无序映射，每个元素都含有一个键值对，键是唯一的，内部实现采用哈希表。
（7）unordered_multiset：无序多重集合，允许重复的元素，内部实现采用哈希表。
（8）unordered_multimap：无序多重映射，允许重复的键值对，内部实现采用哈希表。
以上就是STL中的主要容器种类，每种容器都有各自的特性和适用场景，在实际开发中需要根据具体的需求选择合适的容器进行使用。
STL向量（vector）
STL向量（vector）1.接⼝与实现1.1抽象数据类型：⼀组数据模型上定义的⼀组操作数据类型是（char、int等）数据结构：基于特定语⾔的，实现ADT的⼀整套算法。
1.2向量：向量是数组的抽象与泛化，由⼀组元素按线性次序封装⽽成。
特点：1.各元素与（0，n）内的秩⼀⼀对以应 2.元素的类型不限于基本类型 3.操作、管理更加简洁、统⼀与安全 4.可更为便捷的参与复杂数据结构的定制与实现1.3向量的操作insert(0,9)：在0的位置插⼊9put（1，2）修改1位置上的元素为2get(2)获取2上的元素remove(2)移除位置2上的元素并返回size()向量⾥⾯元素的个数disordered()判断向量⾥⾯⽆序的数据对find(5)找有没有5的元素找到返回其下标未找到则返回-1sort()对⾥⾯的元素进⾏排序search(9)查找向量⾥⾯是否有9找到则返回下标，未找到则返回不超过9的最⼤的那个元素的下表（顺序的向量）uniquify()剔除掉向量⾥⾯重复的元素2.可扩充向量2.1 静态空间管理开辟内部数组_elem[]并使⽤⼀段连续的物理空间缺点：会产⽣上溢合下溢2.2 动态空间管理在即将发⽣上溢时适当的扩⼤数组的容量2.3 扩容的策咯容量递增策略（2 4 6 8 10 12）累计增容费时间(O(n2)) 分摊增容时间（O（n））加倍试策略（2 4 8 16）累计增容费时间(O(n)) 分摊增容时间（O（1））2.4 分摊复杂度平均复杂度：根据数据结构各种操作出现的概率分布，将对应的成本加权平均分摊谈复杂度：对数据结构连续的实施⾜够多次操作，所需总体成本分摊⾄单次操作。
STL常见函数总结
STL常见函数总结#include<bitset>#include<deque>#include<list>#include<map>#include<set>#include<stack>#include<vector>#include<algorithm>#include<string>#include<queue>容器和算法顺序容器1 vector//支持快速随机访问vector<int> f,f1;vector<int>::iterator iter,q,h;int n,x;f.push_back(x);在尾部插入元素x,返回void;f.insert(iter,x);在iter前面插入x，返回指向新添加元素的迭代器;f.insert(iter,n,x);在iter前面插入n个x，返回void;f.insert(iter,q,h);在迭代器iter前面插入q和h范围内的所以元素； f.size(); 返回类型：vector<int>::size_type,也可直接用int，longf.empty();返回布尔值f.back();最后一个元素f.front();返回第一个元素f[n] 返回第n个元素f.erase(iter)删除iter指向的元素，返回所删除值后面的元素的迭代器，若删除的是最后一个元素返回f.end()一样的位置f.erase(q,h)删除q-h所有元素（包括q，不包括h)，返回指向后面的的若h就是f.end(),还返回f.end();f.clear();清空所以元素,返回voidf.pop_back()删除最后一个元素，返回void可以直接赋值f1=f;可以直接比较大小f1=swap(f);f.assign(q,h);f先清空，然后把来自另一个vector的从q到h的元素复制进来f.assign(n,x);f先清空，然后赋为n个x2 list//支持快速插入删除,就是个链表f.push_front(x);不能用f[n]来访问f.pop_front();返回void3 deque//双端队列，两头都有vector的高效性质，还，可以实现元素的随机访问f.push_front(x);f[n];f.pop_front();返回void4 stack//后进先出栈s.empty()s.size()s.pop() 删除栈顶元素，不返回值s.top() 返回栈顶元素的值，但不删除栈顶元素s.push(x) 压栈5 queue//先进先出队列s.empty()s.size()s.pop()删除队首元素，不返回值s.front()返回队首值，但不删除s.back()返回队尾值，但不删除s.push(),在最后插入元素6 priority_queue //有优先级管理的队列s.empty()s.size()s.pop()删除队首元素，不返回值s.front()返回队首值，但不删除s.top(）返回具有最高优先级的元素，但不删除s.push(),在适当位置插入新元素定义方法priority_queue<int,vector<int>,greater<int>>priority_queue<int,vector<int>,less<int>>priority_queue<int>7 string 和vector差不多其实，特殊的vector?int pos;char ch[100];getline(cin,s);s.insert(iter,t); iter前插ts.insert(iter,n,t); iter前n个插ts.insert(iter,q,h);s.earse(iter);s.earse(q,h);s.insert(pos,n,t);在pos前插入n个ts.insert(pos,s1); 在pos前插入s1s.earse(pos,n);删除pos开始的n个字符s.insert(pos,ch,n);s.insert(pos,ch);s.substr(pos,n)；返回从pos开始的n个字符的字符串s.substr(pos);s.replace(pos.len.s1);删除pos开始的len个字符并以s1代替插进去s.replace(q,h,s1);s.find(s1) s1在s中第一次出现的位置s.rfind(s1) s1在s中最后一次出现的位置s.find_first_of(s1) 在s中查找s任意字符第一次出现s.find_last_of(s1) 在s中查找s任意字符最后一次出现s.find_first_not_of(s1)s.find_last_not_of(s1)每个s1都有四种重载版本 s1,pos（从pos开始找），s1,pos,n(匹配s1的前n个字母）string的比较：s==s1,s>s1,s<s1最一般的pare(s1)pare(pos,n,s1);s从pos开始的n个字符，同理，这里的s1也有多种重载版本关联容器1 map(键值对应），键要可排序类型map<string,int> f;map<string,int>::key_type 键的类型map<string,int>::mapped_type 值的类型map<string,int>::value_type pair类型,其中first为一个常量，而sencond 为一个可变量map中添加元素：直接下标添加：f["hello"]=2;（建立了键后首先赋值为0）(若原来有这个“hello”，则是修改了这个键对应的值）用insert添加新元素：f.insert(map<string,int>::value_type("hello",1));f.insert(make_pair("hello",1));insert(pair),返回一个pair类型（ pair<map<string,int>::iteratro, bool> ret）对象，包括一个指向插入键的迭代器，和bool类型的判断是否插入的布尔值，如果键已经存在，就不插入了map中查找，读取元素下标读取有危险(如果没有会插入）f.count("hello") 返回”hello"出现的次数，对于map，返回的就是0或1 f.find("hello") 返回对应的迭代器，否则返回f.end()处删除元素：f.erase(),1传入键（返回0or1)，2传入迭代器(void)，3传入一对迭代器(void)2 setset<int> set1,set2;添加元素：set1.insert(x);set2.insert(set1.begin(),set1.end());set1.find(x);set1.count(x);set1.erase(x);1 bitsetbitset<100> f;f.any() 是否存在为1的二进制位f.none()f.size()f[n]f.test(n)f.set() 全部置为1f.set(n) 第n位置为1f.reset()全部置为0f.reset(n)f.flip()逐位取反f.flip(n)f.to_ulong()把它返回会unsigned long1 algorithmuniquefillfill_nreplacereplace_copyaccumulatesortstable_sortcount_if……。
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)之间。
java中vector 原理
java中vector 原理一、vector概述在Java中，vector是一种常用的动态数据结构，它是一个内置的类，属于STL（Standard Template Library）的一部分。
Vector意为“向量”，它可以用来存储任意类型的数据，并支持随机访问和动态扩展。
这意味着，我们在使用vector时，无需预先定义其大小，它可以根据实际需要自动调整容量。
二、vector的原理1.底层实现Vector底层采用数组来实现，但在实际使用过程中，它会自动进行动态扩容。
当vector的大小超过数组长度时，vector会自动重新分配内存，使得数组长度扩大。
这个过程是透明的，无需程序员手动干预。
2.内存分配与回收Vector在创建时，会根据当前的大小分配内存。
当vector容量不足时，它会自动扩容，从而确保能容纳更多的元素。
在vector空闲时，它会回收部分内存，以减少内存占用。
这种内存管理策略有助于降低内存泄漏的风险。
3.高效性分析Vector的随机访问性能很好，因为它底层使用数组实现。
但由于需要动态扩容，所以在插入和删除元素时，性能会受到影响。
当需要频繁插入和删除元素时，使用其他数据结构（如List）可能会更加高效。
三、vector的使用注意事项1.避免频繁地调整vector的大小。
频繁地扩容和缩容会影响性能，因此，在创建vector时，可以预估其大致容量，以减少不必要的调整。
2.当vector不再需要时，及时释放内存。
可以使用vector的clear()方法清空数据，从而减少内存占用。
3.慎用vector的push_back()和pop_back()方法。
这些方法在插入和删除元素时，效率较低，可能导致性能瓶颈。
在需要频繁插入和删除元素的场景下，可以考虑使用其他数据结构。
四、总结Vector作为一种动态数据结构，在Java编程中有着广泛的应用。
了解其底层实现和原理，可以帮助我们更好地利用vector，提高程序的性能和内存利用率。
stl容器set,map,vector之erase用法与返回值详细解析
stl容器set,map,vector之erase⽤法与返回值详细解析总结本⼈在⼯作中经验教训。
在使⽤ list、set 或 map遍历删除某些元素时可以这样使⽤：复制代码代码如下:std::list< int> List;std::list< int>::iterator itList;for( itList = List.begin(); itList != List.end(); ){if( WillDelete( *itList) ){itList = List.erase( itList);}elseitList++;}复制代码代码如下:std::list< int> List;std::list< int>::iterator itList;for( itList = List.begin(); itList != List.end(); ){if( WillDelete( *itList) ){List.erase(itList++);}elseitList++;}复制代码代码如下:std::list< int> List;std::list< int>::iterator it, next;for( it = List.begin(), next = it, next ++; it != List.end(); it = next, ++next){if( WillDelete( *it) ){List.erase(it);}}注：⽅法三更为巧妙,但需注意⽅法三是⽤前需要判断容器是否为空，否则迭代器会出问题。
我测试得出，set.erase 不返回迭代器，list返回。
vector 删除操作复制代码代码如下:std::vector <PACK_PRINT>::iterator It ;for(It=printItems.begin();It!=printItems.end();){//我是说这⾥怎么判断printItems printItems ⾥PACK_PRINT.bh =0if( It.bh ==0) //是这样吗?{//删除It=printItems.erase(It);}else{//不删除++It;}}复制代码代码如下:std::vector <PACK_PRINT> printItems;int i = 0;while(i < printItems.size()){if(printItems[i].bh == 0) //这⾥⽐如我想把 printItems 时PACK_PRINT.bh =0 的删除如何写哟。
STL vectot 容器详解
介绍 这篇文章的目的是为了介绍 std::vector，如何恰当地使用它们的成员函数等操作。本文中还 讨论了条件函数和函数指针在迭代算法中使用，如在 remove_if()和 for_each()中的使用。通 过阅读这篇文章读者应该能够有效地使用 vector 容器，而且应该不会再去使用 C 类型的动 态数组了。
创建一个包含 500 个 Widget 类型数据的 vector： vector<Widget> vWidgets(500);
创建一个包含 500 个 Widget 类型数据的 vector，并且都初始化为 0： vector<Widget> vWidgets(500, Widget(0));
创建一个 Widget 的拷贝：
然后处理条件判断： class FindMatchingString : public std::unary_function<CString, bool> {
public: FindMatchingString(const LPFINDSTR lpFS) : m_lpFS(lpFS) {}
bool operator()(CString& szStringToCompare) const { bool retVal = false;
} case FM_CONTAINS: { retVal = (szStringToCompare.Find(m_lpFDD->szMatchStr) != -1); break; } }
STL常用容器
STL常用容器STL是C/C++开发中一个非常重要的模板，而其中定义的各种容器也是非常方便我们大家使用。
下面，我们就浅谈某些常用的容器。
这里我们不涉及容器的基本操作之类，只是要讨论一下各个容器其各自的特点。
STL中的常用容器包括：顺序性容器（vector、deque、list）、关联容器（map、set）、容器适配器（queue、stac）。
1、顺序性容器（1）vectorvector是一种动态数组，在内存中具有连续的存储空间，支持快速随机访问。
由于具有连续的存储空间，所以在插入和删除操作方面，效率比较慢。
vector有多个构造函数，默认的构造函数是构造一个初始长度为0的内存空间，且分配的内存空间是以2的倍数动态增长的，即内存空间增长是按照20,21,22,23.....增长的，在push_back的过程中，若发现分配的内存空间不足，则重新分配一段连续的内存空间，其大小是现在连续空间的2倍，再将原先空间中的元素复制到新的空间中，性能消耗比较大，尤其是当元素是非内部数据时(非内部数据往往构造及拷贝构造函数相当复杂)。
vector的另一个常见的问题就是clear操作。
clear函数只是把vector的size清为零，但vector中的元素在内存中并没有消除，所以在使用vector的过程中会发现内存消耗会越来越多，导致内存泄露，现在经常用的方法是swap函数来进行解决： vector V;V.push_back(1); V.push_back(2);V.push_back(1); V.push_back(2);vector().swap(V); 或者 V.swap(vector());利用swap函数，和临时对象交换，使V对象的内存为临时对象的内存，而临时对象的内存为V对象的内存。
交换以后，临时对象消失，释放内存。
（2）dequedeque和vector类似，支持快速随机访问。
二者最大的区别在于，vector只能在末端插入数据，而deque支持双端插入数据。
c++ vector的resize函数
c++ vector的resize函数1. 引言1.1 概述在C++编程语言中，vector是一个动态数组容器，提供了灵活的内存管理和使用方便的操作函数。
其中，resize函数作为vector类的一员，用于调整容器大小。
本文将详细介绍C++ vector的resize函数及其相关知识。
1.2 文章结构本篇文章将分为五个部分进行介绍和讨论。
首先，在引言部分简要概述了整篇文章的内容安排。
接下来讲解C++ vector的基本特点、使用场景以及与静态数组的比较。
随后介绍C++ vector中resize函数的概念、用法以及对内存管理的影响。
在第四部分中，我们将考量resize函数的性能，并提供优化技巧和注意事项。
最后，在结论与总结部分对文章进行小结，并重点总结C++ vector 的resize函数特点与用法，并归纳了相关性能考量以及优化技巧。
1.3 目的随着软件开发项目越来越复杂和庞大，对于内存管理和性能方面的需求也日益增加。
因此，深入理解和掌握C++ vector类以及其成员函数resize的使用方法、底层原理和优化技巧可以帮助我们更好地应对实际开发中的挑战。
本文的目的是为读者提供一份全面而详细的关于C++ vector的resize函数的指南，以便于读者在实际项目中能够灵活运用和优化该函数，达到更高效的编程效果。
2. C++ vector介绍：2.1 定义和特点：C++中的vector是一种动态数组容器，可以根据需要动态调整大小。
它是标准模板库（STL）中的一部分，使用vector可以方便地管理元素的插入、删除和访问。
和静态数组相比，vector具有以下几个特点：- 动态长度：vector可以根据需要自动扩展或缩小大小，无需手动调整。
- 内存管理：vector负责内部元素的内存分配和释放，无需手动操作。
- 随机访问：可以通过下标直接访问vector中的元素。
- 尾部插入和删除效率高：在尾部进行插入和删除操作时，效率非常高。
最全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)。
用静态数组初始化vector一维情况：int vv[2] = { 12,43 };std::vector<int> v(&vv[0], &vv[0]+2);Or, for the case of assignment to an existing vector:int vv[2] = { 12,43 };v.assign(&vv[0], &vv[0]+2);// the iterator constructor can also be used to construct from arrays: int myints[] = {16,2,77,29};vector<int> fifth (myints, myints + sizeof(myints) / sizeof(int) );二维情况：int arr[4][8] ={{1, 2, 3, 4, 5, 6, 7, 8},{1, 2, 3, 4, 9, 10, 11, 12},{1, 2, 5, 6, 9, 10, 13, 14},{1, 3, 5, 7, 9, 11, 13, 15},};std::vector<std::vector<int> > vec(4, std::vector<int>(8));for (int i = 0; i < 4; ++i){vec[i].assign(arr[i], arr[i] + 8);}例子：float arrOfPos[][2] = { {501,10}, {501,128} };int nPosNum = sizeof(arrOfPos) / sizeof(float) / 2;vector< vector<float> > vecOfPos(nPosNum, vector<float>(2, 0));for (int i = 0; i < nPosNum; i++)vecOfPos[i].assign(arrOfPos[i], arrOfPos[i]+2);float arrOfNeg[][2] = { {255, 10}, {501, 255}, {10, 501} };int nNegNum = sizeof(arrOfNeg) / sizeof(float) / 2;vector< vector<float> > vecOfNeg(nNegNum, vector<float>(2, 0));for (int i = 0; i < nNegNum; i++)vecOfNeg[i].assign(arrOfNeg[i], arrOfNeg[i]+2);删除指定的元素：for(vector<int>::iterator iter=veci.begin(); iter!=veci.end();注意此处){if( *iter == 3)iter = veci.erase(iter); // An iterator that designates the first element remaining beyond any elements removed, or a pointer to the // end of the vector if no such element exists//在erase后，it失效，并不是指向vector的下一个元素，it成了一个“野指针”,返回的是指向下一个元素的迭代器elseiter ++ ;}vector中insert()的用法详解iterator insert( iterator loc, const TYPE &val );void insert( iterator loc, size_type num, const TYPE &val );void insert( iterator loc, input_iterator start, input_iterator end );insert() 函数有以下三种用法:在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器,在指定位置loc前插入num个值为val的元素在指定位置loc前插入区间[start, end)的所有元素 .注意点：insert是插入到指定position的前面，而不是后部。
The vector is extended by inserting new elements before the element at the specified position, effectively increasing the container size by the number of elements inserted.This causes an automatic reallocation of the allocated storage space if -and only if- the new vector size surpasses the current vector capacity.在一个vector尾部append另一组数据：#include <vector>#include <iostream>using namespace std;int main() {vector<int> nums;for(int i = 1; i <= 10; ++i)nums.push_back(i);vector<int> appends;for(int i = -5; i <= -1; ++i)appends.push_back(i);nums.insert(nums.end(), appends.begin(), appends.end()) ;for(int i = 0; i < nums.size(); ++i)cout<<nums[i]<<' ';cout<<endl;return 0;}结果：Compiling the source code....$g++ -std=c++11 main.cpp -o demo -lm -pthread -lgmpxx -lgmp -lreadline 2>&1 Executing the program....$demo 1 2 3 4 5 6 7 8 9 10 -5 -4 -3 -2 -1在vector中循环插入长度相等的vector：vector<int> subnums;for(int i = 1; i <= 10; ++i)subnums.push_back(i);vector<int> nums(40, 0);nums.reserve(50);cout << "capacity" << nums.capacity() <<endl; // 50for(int i = 0; i < 4; i++) {nums.insert(nums.begin()+((i)*10), subnums.begin(), subnums.end()) ;for(int i = 0; i < nums.size(); ++i)cout<<nums[i]<<' ';cout<<endl;}Compiling the source code....$g++ -std=c++11 main.cpp -o demo -lm -pthread -lgmpxx -lgmp -lreadline 2>&1Executing the program....$demo1 2 3 4 5 6 7 8 9 10 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 01 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 01 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 01 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0Insert会自动增加内存vector<int> nums;for(int i = 0; i < 4; i++) {nums.insert(nums.end(), subnums.begin(), subnums.end()) ;for(int i = 0; i < nums.size(); ++i)cout<<nums[i]<<' ';cout<<endl;subnums.push_back(11+i);}Compiling the source code....$g++ -std=c++11 main.cpp -o demo -lm -pthread -lgmpxx -lgmp -lreadline 2>&1Executing the program....$demo 1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10 111 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10 11 1 2 3 4 5 6 7 8 9 10 11 121 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10 11 1 2 3 4 5 6 7 8 9 10 11 12 1 2 3 4 5 6 7 8 9 10 11 12 13Vector内存：关于vector，简单地讲就是一个动态数组，里面有一个指针指向一片连续的内存空间，当空间不够装下数据时会自动申请另一片更大的空间，然后把原有数据拷贝过去，接着释放原来的那片空间；当释放或者说是删除里面的数据时，其存储空间并不会释放，仅仅只是清空了里面的数据。