做百度手机网站关键词排名,徐州最新通知,汽车网站模版,网站建设案例教程视频文章目录 前言一、STL简介1.1 什么是STL1.2 STL的六大组件 二、vector的介绍及使用2.1 vector的介绍2.2 vector的使用2.2.1 vector的定义2.2.2 vector iterator 的使用2.2.3 vector 空间增长问题2.2.4 vector 增删查改 三、vector模拟实现3.1 成员变量3.2 成员函数3.2.1 构造函… 文章目录 前言一、STL简介1.1 什么是STL1.2 STL的六大组件 二、vector的介绍及使用2.1 vector的介绍2.2 vector的使用2.2.1 vector的定义2.2.2 vector iterator 的使用2.2.3 vector 空间增长问题2.2.4 vector 增删查改 三、vector模拟实现3.1 成员变量3.2 成员函数3.2.1 构造函数3.2.2 拷贝构造函数3.2.3 operator3.2.4 size3.2.5 capacity3.2.6 reserve(注意memcpy的拷贝方式)3.2.7 resize3.2.8 operator[]3.2.9 insert涉及迭代器失效3.2.10 erase涉及迭代器失效3.2.11 push_back3.2.12 pop_back3.2.13 迭代器 前言 个人主页小沈YO. 小编介绍欢迎来到我的乱七八糟小星球 专栏C 心愿便利店 本章内容vector 记得 评论 点赞 收藏 关注哦~ 提示以下是本篇文章正文内容下面案例可供参考
一、STL简介
1.1 什么是STL
STL(standard template libaray-标准模板库)是C标准库的重要组成部分不仅是一个可复用的组件库而且是一个包罗数据结构与算法的软件框架
1.2 STL的六大组件 二、vector的介绍及使用
2.1 vector的介绍
vector的文档介绍
vector是表示可变大小数组的序列容器。就像数组一样vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问和数组一样高效。但是又不像数组它的大小是可以动态改变的而且它的大小会被容器自动处理。本质讲vector使用动态分配数组来存储它的元素。当新元素插入时候这个数组需要被重新分配大小为了增加存储空间。其做法是分配一个新的数组然后将全部元素移到这个数组。就时间而言这是一个相对代价高的任务因为每当一个新的元素加入到容器的时候vector并不会每次都重新分配大小。vector分配空间策略vector会分配一些额外的空间以适应可能的增长因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何重新分配都应该是对数增长的间隔大小以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。因此vector占用了更多的存储空间为了获得管理存储空间的能力并且以一种有效的方式动态增长。与其它动态序列容器相比deque, list and forward_list vector在访问元素的时候更加高效在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作效率更低。比起list和forward_list统一的迭代器和引用更好。
2.2 vector的使用
2.2.1 vector的定义
(constructor)构造函数声明接口说明vector()重点无参构造vectorsize_type n, const value_type val value_type()构造并初始化n个valvector (const vector x); 重点拷贝构造vector (InputIterator first, InputIterator last);使用迭代器进行初始化构造
void test_vector1()
{//构造函数vectorint v;//无参构造vectorint v1(5, 1);vectorint v2(v1.begin(), v1.end());string s1 hello world;vectorint v3(s1.begin(), s1.end());//隐式类型转换vectorint v4(v3);//拷贝构造
}2.2.2 vector iterator 的使用
iterator的使用接口说明begin end重点获取第一个数据位置的iterator/const_iterator,获取最后一个数据的下一个位置的iterator/const_iteratorrbegin rend获取最后一个数据位置的reverse_iterator,获取第一个数据前一个位置的reverse_iterator void test_vector1()
{vectorint v2(v1.begin(), v1.end());string s1 hello world;vectorint v3(s1.begin(), s1.end());//隐式类型转换vectorint v4(v3);//拷贝构造//1.iteratorvectorint::iterator it v3.begin();while (it ! v3.end()){cout *it ;it;}cout endl;//2.operator[]for (size_t i 0; i v2.size(); i){cout v2[i] ;}cout endl;//3.范围forfor (auto e : v4){cout e ;}cout endl;
}2.2.3 vector 空间增长问题
容量空间接口说明size获取数据个数capacity获取容量大小empty判断是否为空resize重点改变vector的sizereserve 重点改变vector的capacity
// 测试vector的默认扩容机制
void TestVectorExpand()
{size_t sz;vectorint v;sz v.capacity();cout making v grow:\n;for (int i 0; i 100; i) {v.push_back(i);if (sz ! v.capacity()) {sz v.capacity();cout capacity changed: sz \n;}}
}#mermaid-svg-VIVjAPKQEkhn6oeY {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-VIVjAPKQEkhn6oeY .error-icon{fill:#552222;}#mermaid-svg-VIVjAPKQEkhn6oeY .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-VIVjAPKQEkhn6oeY .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-VIVjAPKQEkhn6oeY .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-VIVjAPKQEkhn6oeY .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-VIVjAPKQEkhn6oeY .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-VIVjAPKQEkhn6oeY .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-VIVjAPKQEkhn6oeY .marker{fill:#333333;stroke:#333333;}#mermaid-svg-VIVjAPKQEkhn6oeY .marker.cross{stroke:#333333;}#mermaid-svg-VIVjAPKQEkhn6oeY svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-VIVjAPKQEkhn6oeY .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-VIVjAPKQEkhn6oeY .cluster-label text{fill:#333;}#mermaid-svg-VIVjAPKQEkhn6oeY .cluster-label span{color:#333;}#mermaid-svg-VIVjAPKQEkhn6oeY .label text,#mermaid-svg-VIVjAPKQEkhn6oeY span{fill:#333;color:#333;}#mermaid-svg-VIVjAPKQEkhn6oeY .node rect,#mermaid-svg-VIVjAPKQEkhn6oeY .node circle,#mermaid-svg-VIVjAPKQEkhn6oeY .node ellipse,#mermaid-svg-VIVjAPKQEkhn6oeY .node polygon,#mermaid-svg-VIVjAPKQEkhn6oeY .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-VIVjAPKQEkhn6oeY .node .label{text-align:center;}#mermaid-svg-VIVjAPKQEkhn6oeY .node.clickable{cursor:pointer;}#mermaid-svg-VIVjAPKQEkhn6oeY .arrowheadPath{fill:#333333;}#mermaid-svg-VIVjAPKQEkhn6oeY .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-VIVjAPKQEkhn6oeY .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-VIVjAPKQEkhn6oeY .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-VIVjAPKQEkhn6oeY .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-VIVjAPKQEkhn6oeY .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-VIVjAPKQEkhn6oeY .cluster text{fill:#333;}#mermaid-svg-VIVjAPKQEkhn6oeY .cluster span{color:#333;}#mermaid-svg-VIVjAPKQEkhn6oeY div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-VIVjAPKQEkhn6oeY :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 1 .VS下的结果:capacity是按1.5倍增长的 #mermaid-svg-8pra3zyw95lfgv0R {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-8pra3zyw95lfgv0R .error-icon{fill:#552222;}#mermaid-svg-8pra3zyw95lfgv0R .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-8pra3zyw95lfgv0R .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-8pra3zyw95lfgv0R .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-8pra3zyw95lfgv0R .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-8pra3zyw95lfgv0R .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-8pra3zyw95lfgv0R .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-8pra3zyw95lfgv0R .marker{fill:#333333;stroke:#333333;}#mermaid-svg-8pra3zyw95lfgv0R .marker.cross{stroke:#333333;}#mermaid-svg-8pra3zyw95lfgv0R svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-8pra3zyw95lfgv0R .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-8pra3zyw95lfgv0R .cluster-label text{fill:#333;}#mermaid-svg-8pra3zyw95lfgv0R .cluster-label span{color:#333;}#mermaid-svg-8pra3zyw95lfgv0R .label text,#mermaid-svg-8pra3zyw95lfgv0R span{fill:#333;color:#333;}#mermaid-svg-8pra3zyw95lfgv0R .node rect,#mermaid-svg-8pra3zyw95lfgv0R .node circle,#mermaid-svg-8pra3zyw95lfgv0R .node ellipse,#mermaid-svg-8pra3zyw95lfgv0R .node polygon,#mermaid-svg-8pra3zyw95lfgv0R .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-8pra3zyw95lfgv0R .node .label{text-align:center;}#mermaid-svg-8pra3zyw95lfgv0R .node.clickable{cursor:pointer;}#mermaid-svg-8pra3zyw95lfgv0R .arrowheadPath{fill:#333333;}#mermaid-svg-8pra3zyw95lfgv0R .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-8pra3zyw95lfgv0R .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-8pra3zyw95lfgv0R .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-8pra3zyw95lfgv0R .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-8pra3zyw95lfgv0R .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-8pra3zyw95lfgv0R .cluster text{fill:#333;}#mermaid-svg-8pra3zyw95lfgv0R .cluster span{color:#333;}#mermaid-svg-8pra3zyw95lfgv0R div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-8pra3zyw95lfgv0R :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 2 .Linux下的结果g:是按2倍增长的 capacity的代码在vs和g下分别运行会发现vs下capacity是按1.5倍增长的g是按2倍增长的。这个问题经常会考察不要固化的认为vector增容都是2倍具体增长多少是根据具体的需求定义的。vs是PJ版本STLg是SGI版本STL。 reserve只负责开辟空间如果确定知道需要用多少空间reserve可以缓解vector增容的代价缺陷问题。
// 如果已经确定vector中要存储元素大概个数可以提前将空间设置足够
// 就可以避免边插入边扩容导致效率低下的问题了
void TestVectorExpandOP()
{vectorint v;size_t sz v.capacity();v.reserve(100); // 提前将容量设置好可以避免一遍插入一遍扩容cout making bar grow:\n;for (int i 0; i 100; i) {v.push_back(i);if (sz ! v.capacity()){sz v.capacity();cout capacity changed: sz \n;}}
}resize在开空间的同时还会进行初始化影响size
void test_vector3()
{vectorint v1;cout v1.max_size() endl;size_t sz;vectorint v;//v.reserve(100); --- size0,capacity100v.resize(100); --- size100,capacity100//for (size_t i 0; i v.size(); i)//当写成这种形式用reserve(100)是不会进入循环的因为v.size()返回值是0for (size_t i 0; i 100; i){v[i] i;//断言在release下不起作用//虽然空间开出来了100但是不能访问因为operator[]里面加了断言断言访问的下标必须是小于size的,大于size就越界了,所以只能访问[0size-1]的数据,但是reverse(100)---size0}for (auto e : v){cout e ;}cout endl;
}上面的代码用reserve(100)虽然给 v 提前开了 100 个空间但是 v 中的有效元素个数size还是 0所以不能直接通过下标去访问 vector 对象中的每一个元素因为 operator[ ] 实现中的第一步就是检查下标的合理性防止越界访问执行 assert(pos _size)而此时 _size 是 0就会越界报错。而把 reserve 改成 resize 就可以正常运行因为 resize 会改变 _size 的大小。
2.2.4 vector 增删查改
vector增删查改接口说明push_back重点尾插pop_back 重点尾删find查找 - - -注意这个是算法模块实现不是vector的成员接口insert在position之前插入valerase删除position位置的数据swap交换两个vector的数据空间operator[] 重点像数组一样访问 vectorint v;v.push_back(1);v.push_back(2);v.push_back(3);v.push_back(4);v.push_back(5);v.insert(v.begin(), 0);auto itfind(v.begin(), v.end(), 3);寻找---注意这个是算法模块实现不是vector的成员接口if (it ! v.end()){v.insert(it, 30);插入}for (auto e : v){cout e ;}cout endl;it find(v.begin(), v.end(), 3);if (it ! v.end()){v.erase(it);删除}for (auto e : v){cout e ;}cout endl;cout v.size() endl;cout v.capacity() endl;v.clear();v.shrink_to_fit();//缩容不建议用cout v.size() endl;cout v.capacity() endl;
}三、vector模拟实现 3.1 成员变量
class vector
{
public:typedef T* iterator;typedef const T* const_iterator;
private:iterator _start;iterator _finish;iterator _end_of_storage;
};3.2 成员函数
3.2.1 构造函数
//无参构造
vector():_start(nullptr),_finish(nullptr),_end_of_storage(nullptr){}
//带参构造并初始化
vector(int n, const T val T())
{reserve(n);for (int i 0; i n; i){push_back(val);}
}vector(size_t n, const T val T())
{rserve(n);for (size_t i 0; i n; i){push_back(val);}
}
//迭代器区间初始化
templateclass InputIterator
vector(InputIterator first, InputIterator last)
{while (first ! last){push_back(*first);first;}
}无参的构造并不陌生带参的构造并初始化为什么要写两个
因为如果不单独提供一个 vector(int n, const T val T())代码vector v1(10, 1) 会走最匹配的即和迭代器区间初始化函数匹配迭代器区间初始化采用的是函数模板但是我们希望它走 vector(size_t n, const T val T()) 构造函数可是 10 是 int 型和 size_t 不匹配上只会走最匹配的因此就会去和迭代器区间初始化函数进行匹配InputIterator 就会被实例化成 int 型函数中会对 int 型解引用就会报错
迭代器区间初始化采用的是函数模板因为它可能使用不同类型的迭代器。
3.2.2 拷贝构造函数
vector(const vectorT v)//const对象:_start(nullptr), _finish(nullptr), _end_of_storage(nullptr)
{reserve(v.capacity());for (auto e : v)//这里加上防止T是个大对象拷贝代价大{push_back(e);}
}3.2.3 operator
vectorT operator(vectorT tmp)
{swap(tmp);return *this;
}
void swap(vectorT v)
{std::swap(_start, v._start);std::swap(_finish, v._finish);std::swap(_end_of_storage, v._end_of_storage);
}3.2.4 size
size_t size() const
{return _finish - _start;
}3.2.5 capacity
size_t capacity() const
{return _end_of_storage - _start;
}3.2.6 reserve(注意memcpy的拷贝方式)
void reserve(size_t n)
{if (n capacity()){T* tmp new T[n];if (_start){memcpy(tmp, _start, sizeof(T) * sz);delete[] _start;}_start tmp;_finish _start size();_end_of_storage _start cp;}
}
_________________________________________________________________________________________
void reserve(size_t n)
{if (n capacity()){T* tmp new T[n];if (_start){memcpy(tmp, _start, sizeof(T) * sz);delete[] _start;}_finish tmp size();_start tmp;_end_of_storage _start cp;}
}
_________________________________________________________________________________________
void reserve(size_t n)
{if (n capacity()){size_t sz size();T* tmp new T[n];if (_start){memcpy(tmp, _start, sizeof(T) * sz);delete[] _start;}_start tmp;_finish _start sz;_end_of_storage _start n;}
}注意第一种代码的写法是不正确的因为当开辟新空间tmp将_start中的数据拷贝到tmp中释放原空间将_start指针指向新空间所以运行代码_finish _start size();时要先调用size()而size_finish - _start其中_finish是nullptr构造时初始化而_start并不是nullptr此时是tmp所以我们预期中的size并不是等于0而是size0-_start所以_finish_start0-_start0 解决方式
写成_finish tmp size(); _start tmp;注意先后顺序如果写成 _start tmp; _finish tmp size(); 先调用size_finish-_start0-tmp;最终_finishtmp0-tmp还是没有解决问题同样也不能写成_finish _start size(); _start tmp; 此时的_start0所以_finish000也是不对的第一种的解决方式是可以的但是可读性太差顺序不对就导致错误所以可以提前用一个变量存储size()的返回值size_t sz size();此时就不会因为顺序报错啦
上面这种扩容逻辑当 T 是内置类或者是不需要进行深拷贝的自定义类型来说是可以的。但是当 T 是需要进行深拷贝的类型时上述这种扩容方式就会出现问题。下述代码以 vector 为例
void reserve(size_t n)
{if (n capacity()){size_t sz size();T* tmp new T[n];if (_start){memcpy(tmp, _start, sizeof(T) * sz);delete[] _start;}_start tmp;_finish _start sz;_end_of_storage _start n;}
}
void test_vector5()
{vectorstring s;s.push_back(11111111111111111111);s.push_back(11111111111111111111);s.push_back(11111111111111111111);s.push_back(11111111111111111111);s.push_back(11111111111111111111);for (auto e : s){cout e ;}cout endl;
}通过上图可以明显地观察到当插入4个字符串时是没有问题的但是当插入第五个字符串时就会出现问题显然是扩容中出现了问题上述代码用 memcpy 将旧空间的数据拷贝到新空间那么新旧空间中存储的 string 对象指向同一个堆区上的字符串空间接着在执行 delete[] _start; 销毁旧空间的时候由于该 _start 是一个 string* 的指针所以会先调用 string 的析构函数将对象中申请的空间释放也就是释放 _str 指向的空间然后再去调用 operator delete 函数释放 string 对象的空间。所以新空间中存储的 string 对象就出现了问题因为它的成员变量 _str 指向的空间已经被释放了。 显然 memcpy 执行的是浅拷贝只需要修改成tmp[i] _start[i]; 这样会调用 string 对象的赋值运算重载进行深拷贝。
void reserve(size_t n)
{if (n capacity()){size_t sz size();T* tmp new T[n];if (_start){//memcpy(tmp, _start, sizeof(T) * sz);for (size_t i0;isz;i){tmp[i] _start[i];}delete[] _start;}_start tmp;_finish _start sz;_end_of_storage _start n;}
}3.2.7 resize
void resize(size_t n, const T val T())
{if (n size()){_finish _start n;}else{reserve(n);//填数据while (_finish_startn){*_finish val;_finish;}}
}3.2.8 operator[]
//读写
T operator[](size_t pos)
{assert(pos size());return _start[pos];
}
//只能读
const T operator[](size_t pos) const
{assert(pos size());return _start[pos];
}3.2.9 insert涉及迭代器失效
void insert(iterator pos, const T x)
{assert(pos _start);assert(pos _finish);if (_finish _end_of_storage){reserve(capacity() 0 ? 4 : capacity() * 2);//检查容量}iterator end _finish - 1;//插入数据while (end pos){*(end 1) *end;end--;}*pos x;_finish;
}
___________________________________________________________________________________________-
void insert(iterator pos, const T x)
{assert(pos _start);assert(pos _finish);if (_finish _end_of_storage){size_t len pos - _start;reserve(capacity() 0 ? 4 : capacity() * 2);pos _start len;}iterator end _finish - 1;while (end pos){*(end 1) *end;end--;}*pos x;_finish;
}注意在进行 insert 的时候会引发一个问题 ---- 迭代器失效如果失效就不能再使用这个迭代器如果使用了结果未定义。 首先pos 是一个迭代器在 pos 位置插入一个数据时要在插入数据之前先检查容量进行扩容但是执行了扩容逻辑后_start、_finish、_end_of_storage 都指向了新空间旧空间被释放了且 pos 指向的却还是原来空间中的某个位置此时 pos 就变成了野指针再去 pos 指向的位置插入数据时就会造成非法访问就像第一种所写的代码总而言之就是扩容导致pos失效 解决方式为了解决迭代器失效的问题可以在检查容量扩容之前先保存一下pos的相对位置在进行扩容释放旧空间指向新空间逻辑后更新一下pos指针总而言之就是更新pos
iterator insert(iterator pos, const T x)
{assert(pos _start);assert(pos _finish);if (_finish _end_of_storage){size_t len pos - _start;reserve(capacity() 0 ? 4 : capacity() * 2);pos _start len;}iterator end _finish - 1;while (end pos){*(end 1) *end;end--;}*pos x;_finish;return pos
}
void test_vector3()
{vectorintv;v.push_back(1);v.push_back(2);v.push_back(3);v.push_back(4);v.push_back(5);vectorint::iterator it v.begin()2;v.insert(it, 30);for (auto e : v){cout e ;}cout endl;
}对于上述代码调用insert虽然更新了 pos但是由于是传值形参 pos 的更新并不会改变实参的 it所以insert后it可能会失效。 解决上述问题很简单直接把形参的 pos 变成引用不就可以吗这样形参pos的改变也就使得实参it改变。 这样是可以的解决了传值传参的问题但是也会引发诸多问题例如v.insert(v.begin(), 30);当运行这段代码时就会报错因为实参具有常性begin()是传值返回会产生一个临时变量临时变量具有常性必须要传变量不能传带const属性的值。 所以形参 pos 用引用的话就需要加 const 进行修饰。但是如果用 const 进行修饰那在函数内部就不能对 pos 进行更新所以形参 pos 不能用引用可以采用返回值的方式将更新后的 pos 返回。
3.2.10 erase涉及迭代器失效
iterator erase(iterator pos)
{assert(pos _start);assert(pos _finish);iterator it pos 1;while (it _finish){*(it - 1) *it;it;}_finish--;return pos
}根据上述insert实现中迭代器失效是因为扩容引起的但是erase 只是删除 pos 位置元素pos 位置之后的元素往前覆盖没有导致空间的改变理论上迭代器不会失效 但是根据上述代码如果 pos 刚好是最后一个元素删完之后 pos 刚好是 _finish 的位置而 _finish 位置是没有元素的那么 pos 就失效了。为了迭代器失效问题还是可以采用返回值的方式返回 pos 下一个位置元素的迭代器。
3.2.11 push_back
void push_back(const T x)
{if (_finish _end_of_storage){reserve( capacity() 0 ? 4 : capacity() * 2);}*_finish x; _finish;
}
__________________________________________________________________________________
//push_back可以直接复用insert
void push_back(const T x)
{insert(end(), x);
}3.2.12 pop_back
void pop_back()
{erase(--end());
}3.2.13 迭代器
iterator begin()
{return _start;
}iterator end()
{return _finish;
}const_iterator begin() const
{return _start;
}
const_iterator end() const
{return _finish;
}vectorint::iterator it v.begin();
while (it ! v.end())
{*it * 10;cout *it ;it;
}
cout endl;
for (auto e : v)
{cout e ;
}cout endl;
}
