当前位置：首页 > news >正文

C++模拟实现vector容器【万字模拟✨】

news 来源：原创 2024/10/1 5:25:06

更多精彩内容.....

🎉❤️播主の主页✨😘

Stark、-CSDN博客

本文所在专栏：

学习专栏C语言_Stark、的博客-CSDN博客

项目实战C系列_Stark、的博客-CSDN博客

数据结构与算法_Stark、的博客-CSDN博客

座右铭：梦想是一盏明灯，照亮我们前行的路，无论风雨多大，我们都要坚持不懈。

根据文档，我们先看一下vector有哪些成员，需要我们完成什么功能。如果你对这些功能有过初步的了解请跳过。【vector - C++ Reference (cplusplus.com)】。

模拟过程

1、新建模拟实现vector类工程项目：

创建新项目->选择C++空项目模板->选择存储路径并修改项目名称为”模拟实现vector类”

2、在“模拟实现vector类”工程项目下新建源程序文件（vector.cpp）和头文件（vector.h）

头文件(.h)

编写vector.h头文件代码

#pragma once

#include <iostream>

#include <cstdlib>

#include <cstring>

#include <initializer_list>

using namespace std;

PS：首先使用pragma预处理指令声明头文件只被包含一次，避免重复包含带来的问题；然后使用include预处理指令包含本程序需要使用的头文件。最后避免每次都使用命名空间的域访问问题，我们使用using将std命名空间进行展开。

namespace str {//自己定义一个命名空间，避免vector与std::vector的二义性template<class T>//使用模板进行泛型编程，增强代码复用性。class vector {//定义vector类public:typedef T* iterator;//将T*类型的指针重命名为iterator(迭代器)。//此处为模拟实现，实际的迭代器为一个特殊的类typedef const T* const_iterator;//将const T*类型的常指针重命名为const_iteratorprotected:iterator _start = nullptr;//线性表的首地址iterator _finish = nullptr;//线性表的尾地址的下一个地址iterator _end_of_storage = nullptr;//线性表可访问的最大有效地址public://成员函数}
}

第一部分：成员函数

本部分声明的函数欲实现功能：初始化顺序表，销毁顺序表。包括无参构造函数，拷贝构造函数，其它构造函数，析构函数，以及赋值运算符重载

#pragma region Member functions

vector() :_start(nullptr), _finish(nullptr), _end_of_storage(nullptr) {}//1.无参构造，使用初始化参数列表对成员变量进行赋初值：nullptr~vector();//2.析构函数vector(int num, const T& _Val = T());//3.线性表开辟num个空间，并全部赋值为_Valvector(const vector<T>& _Right);//4.拷贝构造函数，直接使用同类型的其它变量引用进行赋值vector(std::initializer_list<T> _Ilist);//5.列表初始化构造，即花括号构造template<class InputIterator> vector(InputIterator _First, InputIterator _Last);//6.使用其它类型构造vector，需要传入其他类型的首尾指针vector<T>& operator=(const vector<T>& _Right);//7.赋值运算符重载使用const&类型可以接收左值和右值vector<T>& operator=(std::initializer_list<T> _Ilist);//8.赋值运算符重载，传入列表进行赋值

#pragma endregion

PS：本部分是进行对象构造(construct)与销毁(destruct)的成员函数声明。第一个函数使用到了初始化参数列表初始化成员变量的知识。第三个函数_Val使用默认参数。第六个函数使用到了模板类内定义模板函数的知识点。

第二部分：元素访问

本部分函数声明欲实现功能：获取第i个位置的值，修改第i个值，扩展性补充访问首位元素。包括下标访问运算符重载，索引访问函数at(),首元素访问front(),尾元素访问back()。

#pragma region Elements access

const T& operator[](size_t _Pos)const;//1.重载[]下标访问运算符，const T& at(size_t _Pos)const;//2.索引访问函数const T& front()const;//3.访问首元素const T& back()const;//4.访问尾元素//const_iterator data()const;

#pragma endregion

PS：四个函数均使用&类型，做到了访问的同时可以修改。加上const可以接收左值或右值。

第三部分：迭代器

本部分声明的函数欲实现包括获取首元素地址，尾元素地址等。

#pragma region Iterators

iterator begin();//获取首元素地址iterator end();//获取尾元素地址//reverse_iterator rbegin();//reverse_iterator rend();const_iterator cbegin();//获取首元素地址常量const_iterator cend();//获取尾元素地址常量//const_reverse_iterator crbegin();//const_reverse_iterator crend();

#pragma endregion

第四部分：容量

本部分声明的函数欲实现的功能有：判断顺序表是否为空，获取顺序表的长度。包括：判空函数empty(),大小函数size(),空间函数capacity(),扩容函数resize()和reserve()。

#pragma region Capacity

bool empty()const;size_t size()const;size_t capacity()const;void resize(size_t _Newsize);//扩sizevoid reserve(size_t _Newcapacity);//扩capacity//void shrink_to_fit();

#pragma endregion

PS：三、四部分的实现为遍历顺序表提供基础。同时扩容函数reserve函数为增加元素(插入)提供了很大的帮助。

第五部分：修改

本部分声明的函数欲实现的功能有：插入元素(包括指定位置插入insert()和尾插push_back())，删除函数(包括指定位置删除erase()和尾删pop_back())，清空顺序表(将顺序表置空)clear()，扩展性实现有交换两个顺序表swap()。

#pragma region Midifier

void assign(const_iterator _First,const_iterator _Last);void push_back(const T& _Val);void pop_back();iterator insert(const_iterator _Where,const T& _Val);iterator erase(const_iterator _Where);void swap(vector<T>& _Right);void clear();//emplace();//emplace_back();

#pragma endregion

//最后写一个测试使用的打印函数

void ShowInfo() {iterator it = _start;while (it < _finish) {cout << *it << " ";it++;}cout << endl;
}

源程序文件(.cpp)

编写vector.cpp源程序文件代码

函数1：empty()

	template<class T>bool vector<T>::empty()const {return _start == nullptr;}

PS：直接将顺序表的首地址与空指针进行等于条件判断，如果是空返回True反之False。不涉及成员变量的修改，所以将函数使用const修饰，后续不再对const修饰成员函数进行说明。

函数2：size()

	template<class T>size_t vector<T>::size() const {return(_finish - _start);}

PS：使用顺序表尾地址减去顺序表首地址，得到的就是元素个数，直接返回。

函数3：capacity()

	template<class T>size_t vector<T>::capacity()const {return (_end_of_storage - _start);}

PS：使用顺序表可访问最大地址减去顺序表首地址，得到的就是空间容量，直接返回。

函数4：reserve()

	template<class T>void vector<T>::reserve(size_t _Newcapacity) {vector<T> old = *this;_start = new T[_Newcapacity];memcpy(_start, old._start, sizeof(T) * old.size());_finish = _start + old.size();_end_of_storage = _start + _Newcapacity;}

PS：创建一个临时vector容器old存储本身数据在内的所有信息。使用new在堆区开辟出新容量大小的空间，存储到_start中。使用memcpy库函数将数据拷贝过来。将_finish设为_start+old.size();_end_of_storage设为_start+_Newcapacity。这样的话就解决了容器空间不够的问题，但此处存在一个隐患，就是迭代器失效的问题。会在很多地方考虑到这种情况，遇到时再作说明。

函数5：begin()

	template<class T>typename vector<T>::iterator vector<T>::begin() {return _start;}

PS：返回元素的迭代器首位置，直接将顺序表的首地址_start进行返回,无需判断顺序表是否为空，因为如果顺序表为空表，那么_start存储的也是空指针，自行返回nullptr。

函数6：end()

	template<class T>typename vector<T>::iterator vector<T>::end() {return _finish;}

PS：返回元素的迭代器的末尾的后一个位置，也就是_finish。无需判空，原因如上。

函数7：cbegin()

	template<class T>typename vector<T>::const_iterator vector<T>::cbegin() {const_iterator _cbegin = _start;return _cbegin;}

PS：返回元素的迭代器的的首地址的常迭代器，也就是const _start。提前将const _start存储到常迭代器类型中的一个变量_cbegin中，然后返回。也可以选择使用C++提供的强制类型转换增加_start的const属性。

函数8：cend()

	template<class T>typename vector<T>::const_iterator vector<T>::cend() {const_iterator _cend = _finish;return _cend;}

PS：返回元素的迭代器的末尾的后一个地址的常迭代器，也就是const _finish。处理方法同上。

函数9：operator[]()重载

	template<class T>const T& vector<T>::operator[](size_t _Pos)const {if (_Pos < 0 || _Pos >= size())return -1;return _start[_Pos];}

PS：访问第_Pos个元素，并返回该元素的引用。先进行位置有效性判断，看其是否在0和size()之间。如果不在，规定返回-1。否则访问*(_start+_Pos)即_start[_Pos]。

函数10：at()

	template<class T>const T& vector<T>::at(size_t _Pos) const {if (_Pos < 0 || _Pos >= size())return -1;return _start[_Pos];}

函数11：front()

	template<class T>const T& vector<T>::front()const {if (empty())return -1;return *_start;}

PS：访问第1个元素，也就是顺序表首地址_start地址存放的元素。如果不为空就通过解引用符*返回。否则返回-1。如果不进行判断将会导致访问nullptr的非法操作。

函数12：back()

	template<class T>const T& vector<T>::back()const {if (empty())return -1;return *(_finish - 1);}

PS：访问最后一个元素，也就是顺序表尾地址_finish-1地址存放的元素。如果不为空就通过解引用符*返回。否则返回-1。如果不进行判断将会导致访问nullptr的非法操作。

函数13：assign()

	template<class T>void vector<T>::assign(const_iterator _First, const_iterator _Last) {size_t _size = _Last - _First;_start = new T[_size];for (int i = 0; i < _size; i++) {_start[i] = _First[i];}_finish = _start + _size;_end_of_storage = _finish;}

PS：记录传入的两个指针的间隔，即_size。使用new在堆区开辟_size块空间(总字节为_size*sizeof(T))，将开辟的空间的首地址记录在_start中。利用循环，将传入的指针区域内的所有值依次赋给*(_start+i),即_start[i]。为顺序表尾指针_finish赋值_start+_size，顺序表最大可访问地址_end_of_storage赋值_finish。

函数14：erase()

	template<class T>typename vector<T>::iterator vector<T>::erase(const_iterator _Where) {if (_Where < _start || _Where >= _finish)return nullptr;for (iterator it = const_cast<iterator>(_Where); it < _finish - 1; ++it) {*it = *(it + 1);}_finish--;return const_cast<iterator>(_Where);}

PS：对传入的地址进行判断，如果不在_start和_finish之间(左闭右开)，那么返回空指针。否则进行删除操作：利用for循环，从_Where处开始到_finish-2为止。将下一个地址指向的元素覆盖到该位置，该位置的元素即被删除。循环的目的是将后续元素整体向左移动一位。最后将_finish--,尾指针向前移动，原末未被覆盖的尾元素不可访问。利用const_cast<iterator>将_Where强制取消const属性后的指针返回。

函数15：pop_back()

	template<class T>void vector<T>::pop_back() {erase(_finish - 1);//if(empty())return;//_finish--;}

PS：复用erase()函数，传入_finishi-1尾元素地址。另一种思路是，判断_finish是不是空的，如果不是_finish--,直接让有效访问区间在末尾减小一位，反之直接return;返回。

函数16：clear()

	template<class T>void vector<T>::clear() {_end_of_storage = _finish = _start = nullptr;}

PS：将顺序表的三个指针置空就达到了目的。此时会造成内存泄露的问题，在此之前我们可以进行delete[] _start;当然为了保险起见，我们需要在进行delete[] 释放之前加上判断_start是否为nullptr的操作。这里有个注意点，就是delete后面的[]不可省略，因为在开辟堆区空间时开辟的是一段连续空间。（new value_type()与delete value_name匹配，new value_type[]与delete[] value_name匹配，在C++中也可以使用C语言的库函数malloc与free，但不能与C++的new与delete混搭，因为C++的new是malloc+抛异常，delete是free＋抛异常。二者作用类似，但机制不同）

函数17：swap()

	template<class T>void vector<T>::swap(vector<T>& _Right) {vector<T> tmp(*this);*this = _Right;_Right = tmp;}

PS：此处我们采取中间变量进行交换两个顺序表。过程为顺序表1->temp，顺序表2->顺序表1，temp->顺序表2。

函数18：push_back()

	template<class T>void vector<T>::push_back(const T& _Val) {insert(_finish, _Val);}

PS：我们复用下面的insert()函数直接在尾指针处插入元素。

函数19：insert()

	template<class T>typename vector<T>::iterator vector<T>::insert(vector<T>::const_iterator _Where, const T& _Val) {if (_Where< _start || _Where>_finish)return nullptr;//无效范围，插入失败iterator _pos = const_cast<iterator>(_Where);int gap = _pos - _start;while (_finish >= _end_of_storage) {reserve(capacity() == 0 ? 4 : 2 * capacity());_pos = _start + gap;}for (iterator it = _finish; it > _pos; --it) {*it = *(it - 1);}*_pos = _Val;_finish++;return _pos;//返回随机迭代器}

PS：在指定位置插入元素的整体步骤为：定义一个T类型指针it从顺序表尾指针_finish开始，将前一个指针it-1指向的元素移动到当前位置,循环直到it到达_Where结束。然后就可以修改_Where处的元素值，将欲插入的元素直接覆盖未移动走的遗留元素，达到插入的目的。到目前位置，整体过程就叙述完毕。但是，由于要考虑空间大小是否足够的问题，我们就需要进行扩容，while(_finish>=_end_of_storage)reserve(capacity()==0? 4 : 2*capacit())。复用reserve函数进行二倍扩容，考虑到初始可能为0，我们默认赋予4个字节。该扩容过程一直循环_end_of_storage > _finish。此时会出现迭代器失效的问题，所以我们利用记录当前位置指针到表头指针的距离gap，每次扩容都将_pos(=_Where)更新为_start+gap。这样迭代器就随着失效而不断更新有效了。

函数20：~vector();

	template<class T>vector<T>::~vector() {if (_start)delete[] _start;_start = nullptr;_finish = nullptr;_end_of_storage = nullptr;}

PS：该函数为类的析构(_destruct)函数。具体实现代码类似于clear()函数。

函数21：vector(const vector<T>& _Right);与vector<T>& operator=(const vector<T>& _Right);

	template<class T>vector<T>& vector <T>::operator=(const vector<T>& _Right) {size_t s = _Right._finish - _Right._start;_start = new T[s];for (int i = 0; i < s; i++) {*(_start + i) = *(_Right._start + i);}_finish = _start + _Right.size();_end_of_storage = _start + _Right.capacity();return *this;}template<class T>vector<T>::vector(const vector<T>& _Right) {size_t s = _Right._finish - _Right._start;_start = new T[s];for (int i = 0; i < s; i++) {*(_start + i) = *(_Right._start + i);}_finish =_start + _Right.size();_end_of_storage =_start + _Right.capacity();}

PS：二者实现的功能一样，类似于assign()函数，只是传参不同，一个是部分区间，这两个是整段区间。对于构造函数无返回值，赋值运算符重载时需要返回*this。

函数22：vector(std::initializer_list<T> _Ilist);与vector<T>& operator=(std::initializer_list<T> _Ilist);

	template<class T>vector<T>::vector(std::initializer_list<T> _Ilist) {size_t _size = _Ilist.size();_start = new T[_size];_finish = _start;for (T e : _Ilist) {*_finish = e;_finish++;}_end_of_storage = _start + _size;}template<class T>vector<T>& vector<T>::operator=(std::initializer_list<T> _Ilist) {size_t _size = _Ilist.size();_start = new T[_size];_finish = _start;for (T e : _Ilist) {*_finish = e;_finish++;}_end_of_storage = _start + _size;return *this;}

PS：二者实现的功能一样，类似于assign()函数，只是传参不同，一个是部分区间，这两个是元素列表，例如{1,2,5,6,8}就是一个简单的_Ilist。对于构造函数无返回值，赋值运算符重载时需要返回*this。

函数23： template<class T> vector<T>::vector(int num, const T& _Val)

	template<class T>vector<T>::vector(int num, const T& _Val) {_start = new T[num];for (int i = 0; i < num; i++) {_start[i] = _Val;}_finish = _start + num;_end_of_storage=_start + num;}

PS：使用new在堆区开辟num块空间，每块空间由new自动推算(为sizeof(T))，首地址存储在_start中，然后依次访问这num个空间，赋予同样的初值 _Val，如果该值不传，自动调用T类型的构造函数使用类型默认值进行初始化。最后将_finish和_end_of_storage设置为_start+num即可。

函数24：

template<class T>
template<class InputIterator>
vector<T>::vector(InputIterator _First, InputIterator _Last) {size_t _size = _Last - _First;_start = new T[_size];_finish = _start;for (int i = 0; i < _size; i++) {_start[i] = _First[i];_finish++;}_end_of_storage = _finish;
}

PS：该构造函数是为了利用其他容器的指针(模拟迭代器)将其它容器的一段区间复制到该类型的顺序表中。赋值方法不再赘述。

最终代码文件(.hpp)

#pragma once
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <initializer_list>
using namespace std;namespace str {template<class T>class vector {public:				typedef T* iterator;typedef const T* const_iterator;
#pragma region Member functionsvector() :_start(nullptr), _finish(nullptr), _end_of_storage(nullptr) {}~vector();vector(int num, const T& _Val = T());vector(const vector<T>& _Right);vector(std::initializer_list<T> _Ilist);template<class InputIterator> vector(InputIterator _First, InputIterator _Last);vector<T>& operator=(const vector<T>& _Right);vector<T>& operator=(std::initializer_list<T> _Ilist);
#pragma endregion
#pragma region Elements access const T& operator[](size_t _Pos)const;const T& at(size_t _Pos)const;const T& front()const;const T& back()const;//const_iterator data()const;
#pragma endregion
#pragma region Iteratorsiterator begin();iterator end();//reverse_iterator rbegin();//reverse_iterator rend();const_iterator cbegin();const_iterator cend();//const_reverse_iterator crbegin();//const_reverse_iterator crend();
#pragma endregion
#pragma region Capacitybool empty()const;size_t size()const;size_t capacity()const;void resize(size_t _Newsize);//扩sizevoid reserve(size_t _Newcapacity);//扩capacity//void shrink_to_fit();
#pragma endregion
#pragma region Midifiervoid assign(const_iterator _First,const_iterator _Last);void push_back(const T& _Val);void pop_back();iterator insert(const_iterator _Where,const T& _Val);iterator erase(const_iterator _Where);void swap(vector<T>& _Right);void clear();//emplace();//emplace_back();
#pragma endregionvoid ShowInfo() {iterator it = _start;while (it < _finish) {cout << *it << " ";it++;}cout << endl;}protected:iterator _start = nullptr;iterator _finish = nullptr;iterator _end_of_storage = nullptr;};/*----------------------------------------------------------------------------*/
#pragma region FunctionCodes//Capccitytemplate<class T>bool vector<T>::empty()const {return _start == nullptr;}template<class T>size_t vector<T>::size() const {return(_finish - _start);}template<class T>size_t vector<T>::capacity()const {return (_end_of_storage - _start);}template<class T>void vector<T>::reserve(size_t _Newcapacity) {vector<T> old = *this;_start = new T[_Newcapacity];memcpy(_start, old._start, sizeof(T) * old.size());_finish = _start + old.size();_end_of_storage = _start + _Newcapacity;}		template<class T>void vector<T>::resize(size_t _Newsize) {}/*----------------------------------------------------------------------------*///Elements accesstemplate<class T>const T& vector<T>::operator[](size_t _Pos)const {if (_Pos < 0 || _Pos >= size())return -1;return _start[_Pos];}template<class T>const T& vector<T>::at(size_t _Pos) const {if (_Pos < 0 || _Pos >= size())return -1;return _start[_Pos];}template<class T>const T& vector<T>::front()const {if (empty())return -1;return *_start;}template<class T>const T& vector<T>::back()const {if (empty())return -1;return *(_finish - 1);}/*----------------------------------------------------------------------------*///Iteratorstemplate<class T>typename vector<T>::iterator vector<T>::begin() {return _start;}template<class T>typename vector<T>::iterator vector<T>::end() {return _finish;}template<class T>typename vector<T>::const_iterator vector<T>::cbegin() {const_iterator _cbegin = _start;return _cbegin;}template<class T>typename vector<T>::const_iterator vector<T>::cend() {const_iterator _cend = _finish;return _cend;}/*----------------------------------------------------------------------------*///Modifiertemplate<class T>void vector<T>::assign(const_iterator _First, const_iterator _Last) {size_t _size = _Last - _First;_start = new T[_size];for (int i = 0; i < _size; i++) {_start[i] = _First[i];}_finish = _start + _size;_end_of_storage = _finish;}template<class T>typename vector<T>::iterator vector<T>::insert(vector<T>::const_iterator _Where, const T& _Val) {if (_Where< _start || _Where>_finish)return nullptr;//无效范围，插入失败iterator _pos = const_cast<iterator>(_Where);int gap = _pos - _start;while (_finish >= _end_of_storage) {reserve(capacity() == 0 ? 4 : 2 * capacity());_pos = _start + gap;}for (iterator it = _finish; it > _pos; --it) {*it = *(it - 1);}*_pos = _Val;_finish++;return _pos;//返回随机迭代器}template<class T>void vector<T>::push_back(const T& _Val) {insert(_finish, _Val);}template<class T>typename vector<T>::iterator vector<T>::erase(const_iterator _Where) {if (_Where < _start || _Where >= _finish)return nullptr;for (iterator it = const_cast<iterator>(_Where); it < _finish - 1; ++it) {*it = *(it + 1);}_finish--;return const_cast<iterator>(_Where);}template<class T>void vector<T>::pop_back() {erase(_finish - 1);//if(empty())return;//_finish--;}template<class T>void vector<T>::clear() {_end_of_storage = _finish = _start = nullptr;}template<class T>void vector<T>::swap(vector<T>& _Right) {vector<T> tmp(*this);*this = _Right;_Right = tmp;}/*----------------------------------------------------------------------------*///Member functionstemplate<class T>vector<T>& vector <T>::operator=(const vector<T>& _Right) {size_t s = _Right._finish - _Right._start;_start = new T[s];for (int i = 0; i < s; i++) {*(_start + i) = *(_Right._start + i);}_finish = _start + _Right.size();_end_of_storage = _start + _Right.capacity();return *this;}template<class T>vector<T>& vector<T>::operator=(std::initializer_list<T> _Ilist) {size_t _size = _Ilist.size();_start = new T[_size];_finish = _start;for (T e : _Ilist) {*_finish = e;_finish++;}_end_of_storage = _start + _size;return *this;}template<class T>vector<T>::vector(int num, const T& _Val) {_start = new T[num];for (int i = 0; i < num; i++) {_start[i] = _Val;}_finish = _start + num;_end_of_storage=_start + num;}template<class T>vector<T>::vector(const vector<T>& _Right) {size_t s = _Right._finish - _Right._start;_start = new T[s];for (int i = 0; i < s; i++) {*(_start + i) = *(_Right._start + i);}_finish =_start + _Right.size();_end_of_storage =_start + _Right.capacity();}template<class T>vector<T>::vector(std::initializer_list<T> _Ilist) {size_t _size = _Ilist.size();_start = new T[_size];_finish = _start;for (T e : _Ilist) {*_finish = e;_finish++;}_end_of_storage = _start + _size;}template<class T> template<class InputIterator> vector<T>::vector(InputIterator _First, InputIterator _Last) {size_t _size = _Last - _First;_start = new T[_size];_finish = _start;for (int i = 0; i < _size; i++) {_start[i] = _First[i];_finish++;}_end_of_storage = _finish;}template<class T>vector<T>::~vector() {if (_start)delete[] _start;_start = nullptr;_finish = nullptr;_end_of_storage = nullptr;}
#pragma endregion}

测试过程

测试代码：

#include "vector.hpp"
using namespace str;void Test01() {cout << "1号测试机测试开始：" << endl;cout << "测试无参构造函数vector()" << endl;vector<int> v;v.ShowInfo();cout << "测试点1通过" << endl;cout << "测试赋值符重载vector<T>& operator=(std::initializer_list<T> _Ilist)" << endl;v = { 6,3,5,4,9,1 };v.ShowInfo();cout << "测试点2通过" << endl;cout << "测试拷贝构造函数vector(const vector<T>& _Right)" << endl;vector<int> v1(v);v1.ShowInfo();cout << "测试点3通过" << endl;cout << "测试参数列表构造函数vector(std::initializer_list<T> _Ilist)" << endl;vector<int> v2{ 3,3,3,6,6,6 };v2.ShowInfo();cout << "测试点4通过" << endl;cout << "测试赋值重载vector<T>& operator=(const vector<T>& _Right)" << endl;v2 = v;v2.ShowInfo();cout << "测试点5通过" << endl;cout << "测试有参构造函数vector(int num, const T& _Val = T())" << endl;vector<int> v3(5, 9);v3.ShowInfo();cout << "测试点6通过" << endl;cout << "-----------------1号测试机全部测试样例通过--------------------------" << endl;
}
void Test02() {cout << "2号测试机测试开始：" << endl;cout << "测试下标访问符重载 const T& operator[](size_t _Pos)const与const T& at(size_t _Pos)const" << endl;vector<int> v{ 0,1, 2, 3, 4, 5, 6 };cout << v.at(3) << " " << v[4] << endl;cout << "测试点1通过" << endl;cout << "测试const T& front()const 与 const T& back()const" << endl;cout << v.front() << " " << v.back() << endl;cout << "测试点2通过" << endl;cout << "-----------------2号测试机全部测试样例通过--------------------------" << endl;
}
void Test03() {cout << "3号测试机测试开始：" << endl;cout << "测试iterator begin()  与  iterator end()" << endl;vector<int> v{ 0,1, 2, 3, 4, 5, 6 };cout << v.begin() << " " << v.end() << endl;cout << *v.begin() << " " << *(v.end()-1) << endl;cout << "测试点1通过" << endl;cout << "测试const_iterator cbegin() 与 const_iterator cend()" << endl;cout << v.cbegin() << " " << v.cend() << endl;cout << *v.cbegin() << " " << *(v.cend()-1) << endl;cout << "测试点2通过" << endl;cout << "-----------------3号测试机全部测试样例通过--------------------------" << endl;
}
void Test04() {cout << "4号测试机测试开始：" << endl;cout << "测试push_back(),附带insert(),reserve();测试empty(),size(),capacity()" << endl;vector<int> v;if (v.empty())cout << "空表，准备插入元素：" << endl;for (int i = 0; i < 10; i++)v.push_back(i);cout << "size=" << v.size() << " capacity=" << v.capacity() << endl;v.ShowInfo();cout << "-----------------4号测试机全部测试样例通过--------------------------" << endl;
}
void Test05() {cout << "5号测试机测试开始：" << endl;cout << "测试assign(),pop_back()附带erase(),clear()" << endl;vector<int> v{ 1,1,2,3,4,5,6,7,7 };v.ShowInfo();vector<int> sv;sv.assign(v.begin() + 1, v.end() - 1);sv.ShowInfo();sv.pop_back();sv.ShowInfo();sv.clear();if (sv.empty())cout << "测试通过" << endl;cout << "-----------------5号测试机全部测试样例通过--------------------------" << endl;
}
void Test06() {cout << "6号测试机测试开始：" << endl;cout << "测试void swap(const vector<T>& _Right)" << endl;vector<int> v1(10, 5);vector<int> v2(5, 10);cout<<"v1:"; v1.ShowInfo();cout<<"v2:"; v2.ShowInfo();cout << "交换后：" << endl;v1.swap(v2);cout << "v1:"; v1.ShowInfo();cout << "v2:"; v2.ShowInfo();cout << "-----------------6号测试机全部测试样例通过--------------------------" << endl;
}int main() {Test01();Test02();Test03();Test04();Test05();Test06();return 0;
}