更多精彩内容.....

🎉❤️播主の主页✨😘

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命名空间进行展开。

<code>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_iterator

protected:

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个空间，并全部赋值为_Val

vector(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);//扩size

void 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];

}

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

vector() :_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 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

#pragma region Capacity

bool empty()const;

size_t size()const;

size_t capacity()const;

void resize(size_t _Newsize);//扩size

void reserve(size_t _Newcapacity);//扩capacity

//void shrink_to_fit();

#pragma endregion

#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;

}

protected:

iterator _start = nullptr;

iterator _finish = nullptr;

iterator _end_of_storage = nullptr;

};

/*----------------------------------------------------------------------------*/

#pragma region FunctionCodes

//Capccity

template<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 access

template<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);

}

/*----------------------------------------------------------------------------*/

//Iterators

template<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;

}

/*----------------------------------------------------------------------------*/

//Modifier

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;

}

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 functions

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<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;code>

}

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;

}

测试结果：

---

(.hpp)后缀解析

错误：编译->链接阶段出错

1）错误信息：LNK1120(13个无法解析的外部命令)；LNK2019(无法解析外部符号)

2）原因分析：vector类为模板类，不可以分成头文件(.h)和源程序文件(.cpp)编程。

3）解决方案：将模板类的定义及成员函数的类外实现的代码写到一个文件中，约定俗成的后缀名为(.hpp)，代表模板类头文件。 

---

感谢大家观看。