做视频网站付费版,wordpress在哪里输入统计代码,社区网站的推广方案,wordpress插件常用更多精彩内容..... #x1f389;❤️播主の主页✨#x1f618; Stark、-CSDN博客 本文所在专栏#xff1a; 学习专栏C语言_Stark、的博客-CSDN博客 项目实战C系列_Stark、的博客-CSDN博客 数据结构与算法_Stark、的博客-CSDN博客 座右铭#xff1a;梦想是一盏明灯#xff… 更多精彩内容..... ❤️播主の主页✨ 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的二义性templateclass 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 vectorT _Right);//4.拷贝构造函数直接使用同类型的其它变量引用进行赋值vector(std::initializer_listT _Ilist);//5.列表初始化构造即花括号构造templateclass InputIterator vector(InputIterator _First, InputIterator _Last);//6.使用其它类型构造vector需要传入其他类型的首尾指针vectorT operator(const vectorT _Right);//7.赋值运算符重载使用const类型可以接收左值和右值vectorT operator(std::initializer_listT _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(vectorT _Right);void clear();//emplace();//emplace_back();
#pragma endregion
//最后写一个测试使用的打印函数
void ShowInfo() {iterator it _start;while (it _finish) {cout *it ;it;}cout endl;
}
源程序文件(.cpp)
编写vector.cpp源程序文件代码
函数1empty() templateclass Tbool vectorT::empty()const {return _start nullptr;}
PS直接将顺序表的首地址与空指针进行等于条件判断如果是空返回True反之False。不涉及成员变量的修改所以将函数使用const修饰后续不再对const修饰成员函数进行说明。
函数2size() templateclass Tsize_t vectorT::size() const {return(_finish - _start);}
PS使用顺序表尾地址减去顺序表首地址得到的就是元素个数直接返回。
函数3capacity() templateclass Tsize_t vectorT::capacity()const {return (_end_of_storage - _start);}
PS使用顺序表可访问最大地址减去顺序表首地址得到的就是空间容量直接返回。
函数4reserve() templateclass Tvoid vectorT::reserve(size_t _Newcapacity) {vectorT 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设为_startold.size();_end_of_storage设为_start_Newcapacity。这样的话就解决了容器空间不够的问题但此处存在一个隐患就是迭代器失效的问题。会在很多地方考虑到这种情况遇到时再作说明。
函数5begin() templateclass Ttypename vectorT::iterator vectorT::begin() {return _start;}
PS返回元素的迭代器首位置直接将顺序表的首地址_start进行返回,无需判断顺序表是否为空因为如果顺序表为空表那么_start存储的也是空指针自行返回nullptr。
函数6end() templateclass Ttypename vectorT::iterator vectorT::end() {return _finish;}
PS返回元素的迭代器的末尾的后一个位置也就是_finish。无需判空原因如上。
函数7cbegin() templateclass Ttypename vectorT::const_iterator vectorT::cbegin() {const_iterator _cbegin _start;return _cbegin;}
PS返回元素的迭代器的的首地址的常迭代器也就是const _start。提前将const _start存储到常迭代器类型中的一个变量_cbegin中然后返回。也可以选择使用C提供的强制类型转换增加_start的const属性。
函数8cend() templateclass Ttypename vectorT::const_iterator vectorT::cend() {const_iterator _cend _finish;return _cend;}
PS返回元素的迭代器的末尾的后一个地址的常迭代器也就是const _finish。处理方法同上。
函数9operator[]()重载 templateclass Tconst T vectorT::operator[](size_t _Pos)const {if (_Pos 0 || _Pos size())return -1;return _start[_Pos];}
PS访问第_Pos个元素并返回该元素的引用。先进行位置有效性判断看其是否在0和size()之间。如果不在规定返回-1。否则访问*(_start_Pos)即_start[_Pos]。
函数10at() templateclass Tconst T vectorT::at(size_t _Pos) const {if (_Pos 0 || _Pos size())return -1;return _start[_Pos];}
PS访问第_Pos个元素并返回该元素的引用。先进行位置有效性判断看其是否在0和size()之间。如果不在规定返回-1。否则访问*(_start_Pos)即_start[_Pos]。
函数11front() templateclass Tconst T vectorT::front()const {if (empty())return -1;return *_start;}
PS访问第1个元素也就是顺序表首地址_start地址存放的元素。如果不为空就通过解引用符*返回。否则返回-1。如果不进行判断将会导致访问nullptr的非法操作。
函数12back() templateclass Tconst T vectorT::back()const {if (empty())return -1;return *(_finish - 1);}
PS访问最后一个元素也就是顺序表尾地址_finish-1地址存放的元素。如果不为空就通过解引用符*返回。否则返回-1。如果不进行判断将会导致访问nullptr的非法操作。
函数13assign() templateclass Tvoid vectorT::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中。利用循环将传入的指针区域内的所有值依次赋给*(_starti),即_start[i]。为顺序表尾指针_finish赋值_start_size顺序表最大可访问地址_end_of_storage赋值_finish。
函数14erase() templateclass Ttypename vectorT::iterator vectorT::erase(const_iterator _Where) {if (_Where _start || _Where _finish)return nullptr;for (iterator it const_castiterator(_Where); it _finish - 1; it) {*it *(it 1);}_finish--;return const_castiterator(_Where);}
PS对传入的地址进行判断如果不在_start和_finish之间(左闭右开)那么返回空指针。否则进行删除操作利用for循环从_Where处开始到_finish-2为止。将下一个地址指向的元素覆盖到该位置该位置的元素即被删除。循环的目的是将后续元素整体向左移动一位。最后将_finish--,尾指针向前移动原末未被覆盖的尾元素不可访问。利用const_castiterator将_Where强制取消const属性后的指针返回。
函数15pop_back() templateclass Tvoid vectorT::pop_back() {erase(_finish - 1);//if(empty())return;//_finish--;}
PS复用erase()函数传入_finishi-1尾元素地址。另一种思路是判断_finish是不是空的如果不是_finish--,直接让有效访问区间在末尾减小一位反之直接return;返回。
函数16clear() templateclass Tvoid vectorT::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抛异常。二者作用类似但机制不同
函数17swap() templateclass Tvoid vectorT::swap(vectorT _Right) {vectorT tmp(*this);*this _Right;_Right tmp;}
PS此处我们采取中间变量进行交换两个顺序表。过程为顺序表1-temp顺序表2-顺序表1temp-顺序表2。
函数18push_back() templateclass Tvoid vectorT::push_back(const T _Val) {insert(_finish, _Val);}
PS我们复用下面的insert()函数直接在尾指针处插入元素。
函数19insert() templateclass Ttypename vectorT::iterator vectorT::insert(vectorT::const_iterator _Where, const T _Val) {if (_Where _start || _Where_finish)return nullptr;//无效范围插入失败iterator _pos const_castiterator(_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)更新为_startgap。这样迭代器就随着失效而不断更新有效了。
函数20~vector(); templateclass TvectorT::~vector() {if (_start)delete[] _start;_start nullptr;_finish nullptr;_end_of_storage nullptr;}
PS该函数为类的析构(_destruct)函数。具体实现代码类似于clear()函数。
函数21vector(const vectorT _Right);与vectorT operator(const vectorT _Right); templateclass TvectorT vector T::operator(const vectorT _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;}templateclass TvectorT::vector(const vectorT _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。
函数22vector(std::initializer_listT _Ilist);与vectorT operator(std::initializer_listT _Ilist); templateclass TvectorT::vector(std::initializer_listT _Ilist) {size_t _size _Ilist.size();_start new T[_size];_finish _start;for (T e : _Ilist) {*_finish e;_finish;}_end_of_storage _start _size;}templateclass TvectorT vectorT::operator(std::initializer_listT _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 templateclass T vectorT::vector(int num, const T _Val) templateclass TvectorT::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设置为_startnum即可。
函数24
templateclass T
templateclass InputIterator
vectorT::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 {templateclass Tclass 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 vectorT _Right);vector(std::initializer_listT _Ilist);templateclass InputIterator vector(InputIterator _First, InputIterator _Last);vectorT operator(const vectorT _Right);vectorT operator(std::initializer_listT _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(vectorT _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//Capccitytemplateclass Tbool vectorT::empty()const {return _start nullptr;}templateclass Tsize_t vectorT::size() const {return(_finish - _start);}templateclass Tsize_t vectorT::capacity()const {return (_end_of_storage - _start);}templateclass Tvoid vectorT::reserve(size_t _Newcapacity) {vectorT old *this;_start new T[_Newcapacity];memcpy(_start, old._start, sizeof(T) * old.size());_finish _start old.size();_end_of_storage _start _Newcapacity;} templateclass Tvoid vectorT::resize(size_t _Newsize) {}/*----------------------------------------------------------------------------*///Elements accesstemplateclass Tconst T vectorT::operator[](size_t _Pos)const {if (_Pos 0 || _Pos size())return -1;return _start[_Pos];}templateclass Tconst T vectorT::at(size_t _Pos) const {if (_Pos 0 || _Pos size())return -1;return _start[_Pos];}templateclass Tconst T vectorT::front()const {if (empty())return -1;return *_start;}templateclass Tconst T vectorT::back()const {if (empty())return -1;return *(_finish - 1);}/*----------------------------------------------------------------------------*///Iteratorstemplateclass Ttypename vectorT::iterator vectorT::begin() {return _start;}templateclass Ttypename vectorT::iterator vectorT::end() {return _finish;}templateclass Ttypename vectorT::const_iterator vectorT::cbegin() {const_iterator _cbegin _start;return _cbegin;}templateclass Ttypename vectorT::const_iterator vectorT::cend() {const_iterator _cend _finish;return _cend;}/*----------------------------------------------------------------------------*///Modifiertemplateclass Tvoid vectorT::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;}templateclass Ttypename vectorT::iterator vectorT::insert(vectorT::const_iterator _Where, const T _Val) {if (_Where _start || _Where_finish)return nullptr;//无效范围插入失败iterator _pos const_castiterator(_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;//返回随机迭代器}templateclass Tvoid vectorT::push_back(const T _Val) {insert(_finish, _Val);}templateclass Ttypename vectorT::iterator vectorT::erase(const_iterator _Where) {if (_Where _start || _Where _finish)return nullptr;for (iterator it const_castiterator(_Where); it _finish - 1; it) {*it *(it 1);}_finish--;return const_castiterator(_Where);}templateclass Tvoid vectorT::pop_back() {erase(_finish - 1);//if(empty())return;//_finish--;}templateclass Tvoid vectorT::clear() {_end_of_storage _finish _start nullptr;}templateclass Tvoid vectorT::swap(vectorT _Right) {vectorT tmp(*this);*this _Right;_Right tmp;}/*----------------------------------------------------------------------------*///Member functionstemplateclass TvectorT vector T::operator(const vectorT _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;}templateclass TvectorT vectorT::operator(std::initializer_listT _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;}templateclass TvectorT::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;}templateclass TvectorT::vector(const vectorT _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();}templateclass TvectorT::vector(std::initializer_listT _Ilist) {size_t _size _Ilist.size();_start new T[_size];_finish _start;for (T e : _Ilist) {*_finish e;_finish;}_end_of_storage _start _size;}templateclass T templateclass InputIterator vectorT::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;}templateclass TvectorT::~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;vectorint v;v.ShowInfo();cout 测试点1通过 endl;cout 测试赋值符重载vectorT operator(std::initializer_listT _Ilist) endl;v { 6,3,5,4,9,1 };v.ShowInfo();cout 测试点2通过 endl;cout 测试拷贝构造函数vector(const vectorT _Right) endl;vectorint v1(v);v1.ShowInfo();cout 测试点3通过 endl;cout 测试参数列表构造函数vector(std::initializer_listT _Ilist) endl;vectorint v2{ 3,3,3,6,6,6 };v2.ShowInfo();cout 测试点4通过 endl;cout 测试赋值重载vectorT operator(const vectorT _Right) endl;v2 v;v2.ShowInfo();cout 测试点5通过 endl;cout 测试有参构造函数vector(int num, const T _Val T()) endl;vectorint 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;vectorint 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;vectorint 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;vectorint 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;vectorint v{ 1,1,2,3,4,5,6,7,7 };v.ShowInfo();vectorint 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 vectorT _Right) endl;vectorint v1(10, 5);vectorint v2(5, 10);coutv1:; v1.ShowInfo();coutv2:; 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)代表模板类头文件。 感谢大家观看。
