自用，自写，防遗忘
思路从出生，到回归，然后按照应该有的函数进行书写，由于本来就是自用，与stl里面会有部分差异，但是大体一样，此过程用于熟悉vector这个动态数组的概念，可变的数组
MyVector.h 文件，里面的调用只有iostream
#pragma once
#include"stdafx.h"
//stdafx.h里面调用了打印，用来测试跟踪内存来着，现在所有输出都已经注释掉了，其实跟踪释放情况的最好方法就是重载delete
//出错两种解决方案，抛异常或者不管，我选择都不管，谁调用谁出错谁负责，优先保证主体没问题
//由于是模拟，按照自己想法设计，所以有的有，有的没有，有些功能多一些，有些少一点的，毕竟完全设计出stl里的话还不如直接用stl
//所有结尾方式采用的是逾尾结束，因为这样写是< 方便一点
template<class T>
class MyVector
{
T *pBuff; //存储空间
size_t len; //元素个数
size_t Mlen; //变化的最大容量
public:
struct Myiterator //智能指针
{
T *p;
Myiterator() //防意外，出生即为空
{
p = NULL;
}
//重载=，方便进行智能指针的赋值
Myiterator& operator =(Myiterator const& srcIt)
{
p = srcIt.p;
return *this; //返回类型是一个智能指针，不能返回p，返回自身地址this，返回自身地址里的内容*this
}
//重载* 直接获得指针位置的数据
T operator *()
{
return *p;
}
//重载说明 由于是模拟动态数组，我选择的方式是用pBuff开堆内存，而实际stl里的vector由一个参量是内存模型，这个内存模式不让我们使用，所以stl里的vector的智能指针的+，++运算等包括erase等函数和我所设计的MyVector是完全不同的，由于采用new/malloc开辟堆内存，物理位置逻辑位置均连续，所以可以进行下面赋值方法，如选择其他模拟方法，请慎重拷贝，借鉴
//重载+ 指针的+操作是向后移动n个T类型，不是n个位字节
Myiterator operator +(int n)
{
Myiterator it;
it.p = p;
it.p += n;
return it;
//上下两种看习惯，喜欢用哪个就用哪个
//p += n;
//return *this;
}
//重载- 指针快速前移
Myiterator operator -(int n)
{
Myiterator it;
it.p = p;
it.p -= n;
return it;
}
//重载 前++
Myiterator& operator ++()
{
p++;
return *this;
}
//重载后++
Myiterator& operator ++(int)
{
p++;
return *this;
}
//重载前--
Myiterator& operator --()
{
p--;
return *this;
}
//重载后--
Myiterator& operator --(int)
{
p--;
return *this;
}
//重载差，用于返回两个指针之间的元素个数
int operator -(Myiterator const &srcIt) const
{
return p - srcIt.p;
}
//重载!= 判断是否指向同一个位置
bool operator != (Myiterator const &srcIt) const
{
return p != srcIt.p;
}
bool operator ==(Myiterator const &srcIt) const
{
return p == srcIt.p;
}
//智能指针是否需要比大小呢，感觉没必要，没意义，判断谁在前谁在后不知道有什么，因为一旦需要先后关系，都是用来取值，然后判断是否需要直接退出
};
MyVector(); //默认构造
MyVector(int const len); //传入空间大小
MyVector(MyVector &t); //传入同类型vector，拷贝构造
MyVector(int const n, T const& srcDate); //传入n个相同的数
MyVector(T const srcDate[], int const len); //一个数组src，前len个元素
MyVector(Myiterator const begin, Myiterator const end); //用vector的智能指针，截取一段内容
~MyVector(); //析构
//assign 清空数组，并导入不同的元素,Erases a vector and copies the specified elements to the empty vector.
void assign(T const n, T const& srcDate); //导入n个相同的srcDate数据
void assign(Myiterator begin, Myiterator end); //导入vector的一段数据
void assign(T const srcDate[],int const begin,int const end); //导入数组的一段数据
//at 返回处于指令位置的数据，Returns a reference to the element at a specified location in the vector.
T at(int index);
//begin 返回第一个位置 Returns a random - access iterator to the first element in the container.
Myiterator begin();
//end 返回最后一个逾尾位置 Returns a random - access iterator that points just beyond the end of the vector.
Myiterator end();
//front 返回第一个元素 Returns a reference to the first element in a vector.
T front();
//back 返回最后一个元素 Returns a reference to the last element of the vector.
T back();
//capacity 返回容器容量 Returns the number of elements that the vector could contain without allocating more storage.
size_t capacity();
//size 返回容器元素个数 Returns the number of elements in the vector.
size_t size();
//max_size 内存可开辟最大空间，内存模型，系统等决定 Returns the maximum length of the vector.
void max_size();
//clear 清空容器中的元素 Erases the elements of the vector.
void clear();
//empty 检测容器是否为空 Tests if the vector container is empty.
bool empty();
//erase 清除指针位置的元素 Removes an element or a range of elements in a vector from specified positions.
void erase(Myiterator &pos);
void erase(Myiterator &begin, Myiterator &end); //删除一段数据
//没用过 内存模型，不让改动的，除非你是设计师 Returns an object to the allocator class used by a vector.
void get_allocator();
//insert 在智能指针位置插入数据 Inserts an element or a number of elements into the vector at a specified position.
void insert(Myiterator &pos,T const &srcDate);
void insert(Myiterator &pos, T const srcDate[], size_t n); //在指定位置插入一段数据
void insert(Myiterator &pos, Myiterator begin, Myiterator end); //在指定位置插入一段容器里的数据
//pop_back 弹出最后一个元素 Deletes the element at the end of the vector.
T pop_back();
//push_back 在最后添加数据 Add an element to the end of the vector.
void push_back(T const &srcDate);
//rbegin 逆向计算开头 Returns an iterator to the first element in a reversed vector.
Myiterator rbegin();
//rend 逆向计算逾尾终点 Returns an iterator to the end of a reversed vector.
Myiterator rend();
//reserve 更改最大空间,只会扩大不会减小 Reserves a minimum length of storage for a vector object.
void reserve(size_t M);
//resize 更改元素个数，小于已有元素个数，则截取，大于已有元素个数小于容量空间，补0，大于容量空间，重分配，补0 Specifies a new size for a vector.
void resize(size_t n);
// swap 交换一段数据 Exchanges the elements of two vectors.
void swap(MyVector &temp);
void swap(Myiterator begin, Myiterator end); //感觉这个不太合适，但还是先写上，只进行同个数交换
void swap(MyVector &dest, Myiterator begin, Myiterator end); //与另一个容器的一段空间进行交换
//容器的大小关系
bool operator == (MyVector const & srcVector) const;
bool operator != (MyVector const & srcVector) const;
bool operator >(MyVector const &sreVector)const;
bool operator <(MyVector const &sreVector)const;
bool operator >=(MyVector const &sreVector)const;
bool operator <=(MyVector const &sreVector)const;
//容器赋值
void operator =(MyVector const &sreVector)const;
};
template<class T>
MyVector<T>::MyVector() //默认构造
{
pBuff = NULL;
len = 0;
Mlen = 0;
}
// new 一个空间为0的数组也是有地址的，有地址就很危险
template<class T>
MyVector<T>::MyVector(int const len) //只知道空间大小，却没有数据
{
Mlen = len;
this->len = 0;
if (Mlen) //防new 0
pBuff = new T[len]();
else
pBuff = NULL;
}
template<class T>
MyVector<T>::MyVector(T const srcDate[],int const len) //把一个数组里的前n个数据拷过来
{
this->len = len;
Mlen = len;
if (Mlen) //防new 0
{
pBuff = new T[this->len];
memcpy(pBuff, srcDate, sizeof(srcDate)*len); //内存拷贝 memcpy从src位置开始进行内存拷贝
}
else
pBuff = NULL;
}
template<class T>
MyVector<T>::MyVector(int const n, T const &srcDate) //拷入n个src数据
{
len = n;
Mlen = n;
if (len) //防new 0
{
pBuff = new T[len];
for (int i = 0; i < n; i++)
pBuff[i] = srcDate;
}
else
pBuff = NULL;
}
template<class T>
MyVector<T>::MyVector(MyVector &t) //拷贝构造，需要开辟内存深拷贝
{
len = t.len;
Mlen = t.len;
if (len) //防new 0 因为另一个容器可能没有元素，但是有容量，而拷贝的时候我们关注的是里面数据，而不是容量，毕竟是动态数组，容量问题不需要使用者关心
{
pBuff = new T[len];
memcpy(pBuff, t.pBuff, sizeof(T)*len);
}
else
pBuff = NULL;
}
template<class T>
MyVector<T>::MyVector(Myiterator const begin, Myiterator const end) //把一个容器的一段内容拷过来
{
int t = end - begin;
if (t<=0) //智能指针的位置反了，拒绝拷贝，或者删掉这里，直接报错
{
len = 0;
Mlen = 0;
pBuff = NULL;
return;
}
len = t;
Mlen = t;
if (len) //防new 0
{
pBuff = new T[len];
memcpy(pBuff, begin.p, sizeof(T)*len);
}
else
pBuff = NULL;
}
template<class T>
MyVector<T>::~MyVector() //析构
{
if (pBuff)
{
delete[] pBuff;
pBuff = NULL;
//printf("delete\n"); //用于跟踪内存释放
}
}
template<class T>
void MyVector<T>::assign(T const n, T const& srcDate) //修改成n个相同的srcDate数据
{
if (pBuff) //原有数据不要了，需要释放
{
delete[] pBuff;
pBuff = NULL;
//printf("delete\n"); // 跟踪释放情况
}
len = n;
Mlen = n;
if (len) //防止出现0个src然后new 0
{
pBuff = new T[len];
for (int i = 0; i < n; i++)
pBuff[i] = srcDate;
}
}
template<class T>
void MyVector<T>::assign(Myiterator begin, Myiterator end) //修改成vector的一段数据
{
if (pBuff) //删原有数据
{
delete[] pBuff;
pBuff = NULL;
//printf("delete\n"); //跟踪释放情况
}
len = 0;
Mlen = 0;
int t = end-begin; //不知道是否会出现智能指针反了的情况，反了就认为你想弄个0，按理说保险起见应该在加一个pBuff=NULL；但是自信没有出现野指针，出现了别说没提醒
if (t>0)
{
len = t;
Mlen = t;
pBuff = new T[len];
Myiterator temp = begin;
for (int i = 0; i < t;i++)
{
pBuff[i] = *temp; //不建议pBuff【i】，毕竟其本质是个指针，但是谁叫这个用的舒服
++temp;
}
}
}
template<class T>
void MyVector<T>::assign(T const srcDate[], int const begin, int const end) //修改成数组的一段数据，完全是为了和上面的vector一段数据进行匹配，方便使用
{
if (pBuff) //删除原有数据
{
delete[] pBuff;
pBuff = NULL;
//printf("delete\n"); //跟踪释放情况
}
len = 0;
Mlen = 0;
int t = end - begin; //如果方向反了，默认为空
if (t > 0)
{
len = t;
Mlen = t;
pBuff = new T[len];
t = begin;
for (int i = 0; i < t;i++)
pBuff[i] = srcDate[t+i];
}
}
template<class T>
T MyVector<T>::at(int index) //at返回index位置的数据
{
return pBuff[index];
}
template<class T> //依赖名称而不是类型 typename
typename MyVector<T>::Myiterator MyVector<T>::begin() //返回开始位置
{
Myiterator it;
it.p = pBuff;
return it;
}
template<class T>
typename MyVector<T>::Myiterator MyVector<T>::end() //返回逾尾位置
{
Myiterator it;
it.p = pBuff + len;
return it;
}
template<class T>
T MyVector<T>::front() //返回第一个元素
{
return pBuff[0];
}
template<class T>
T MyVector<T>::back() //返回最后一个元素
{
return pBuff[len - 1];
}
template<class T>
size_t MyVector<T>::capacity() //返回容器容量大小
{
return Mlen;
}
template<class T>
size_t MyVector<T>::size() //返回元素个数
{
return len;
}
template<class T>
void MyVector<T>::clear() //把元素清空，但是原有空间保留
{
len = 0;
memset(pBuff, 0, Mlen);
}
template<class T>
bool MyVector<T>::empty() //判断是否动态数组是否为空，提供接口，调用出错
{
if (len == 0)
return true;
return false;
}
template<class T>
void MyVector<T>::erase(Myiterator &pos) //由于我们物理位置逻辑位置均连续，删除后，智能指针还是指向那个位置，不需要变化，而按照stl里面，清除一个数据后，他的智能指针不再安全，会是一个位置值，有时候是下一个，有时候是一个随机值
{
if ((pos-begin()) >= len) //开始提醒有符号无符号的匹配问题，指针位置在数组开头的前面，按理说应该交给调用的时候处理
return;
int index = pos.p - pBuff; //数组的删除很慢
for (int i = index; i < len; i++)
{
pBuff[i] = pBuff[i + 1];
}
len--;
}
template<class T>
void MyVector<T>::erase(Myiterator &begin, Myiterator &end) //删除一段数据
{
int t = end - begin;
//int k = len;
if (end.p - pBuff >= len) //开删除一段数据，如果数据端超过末尾，那么有一段是不需要删除的，但是注意指针本身就存在越界的可能性
t = pBuff + len - begin.p; //pBuff+len 获得末尾位置
if (begin.p - pBuff >= len) //发现删除的起点比元素个数多，没有删的空间
return;
if (t <= 0) //前后关系反了
return;
int indexBeg = begin.p - pBuff; //记录开头
int indexEnd = end.p - pBuff; //记录末尾
while(indexEnd<len) //把末尾的值赋给开头，然后双双移动
{
pBuff[indexBeg] = pBuff[indexEnd];
indexBeg++;
indexEnd++;
}
len = len - t;
}
template<class T>
void MyVector<T>::insert(Myiterator &pos, T const &srcDate) //插入pos位置的一个数据
{
if (len >= Mlen) //应该不会出现大于的情况，保险点写上，等于的时候代表容器容量Mlen里装了len个元素，已经装满了 这段扩展空间的代码应该写成一个函数，毕竟使用了很多次，可以以后开发新功能的时候还需要这个开辟空间
{
Mlen = Mlen + ((Mlen >> 1) > 1 ? (Mlen >> 1) : 1); //近似于1.5倍的一次次扩展
T *tempBuff = new T[Mlen];
memcpy(tempBuff, pBuff, sizeof(T)*len);
if (pBuff)
delete[] pBuff;
pBuff = tempBuff;
}
int index = pos.p - pBuff; //获得插入位置,注意存在插入位置超出末尾的情况
if (index > len)
index = len;
for (int i = len; i > index; i--) //从后往前依次赋值
pBuff[i] = pBuff[i - 1];
pBuff[index] = srcDate;
len++;
}
template<class T>
void MyVector<T>::insert(Myiterator &pos, T const srcDate[], size_t n) //插入一段数据，来源自一个数组的前n个数据
{
int t = len + n; //可能元素很多，需要放大多次，利用flag，一次性拷贝，稍微快一点传输数据，不然放大一次拷贝一次，
bool flag = false;
while (t > Mlen)
{
Mlen = Mlen + ((Mlen >> 1) > 1 ? (Mlen >> 1) : 1);
flag = true;
}
if (flag) //改变容器容量
{
T *tempBuff = new T[Mlen];
int m = pos - begin(); //m记录插入位置
if (m > len)
m = len;
memcpy(tempBuff, pBuff, sizeof(T)*m); //拷贝前半部分数据
for (int i = 0; i < n; i++) //拷贝数组数据
tempBuff[m + i] = srcDate[i];
memcpy(tempBuff + m+n, pBuff + m, sizeof(T)*(len - m)); //拷贝后半部分数据
delete[] pBuff;
pBuff = tempBuff;
len = len + n; //别忘了改变元素个数
return;
}
//下面是没有改变容器容量，没用else可能不太显眼
int m = pos - begin();
if (m>len)
m = len;
for (int i = 0; i < n; i++)
pBuff[len + n - 1 - i] = pBuff[len - 1 - i]; //最后一个元素的位置（结尾）len+需要插入的元素个数n-前一个位置1-计数器i
Myiterator it = pos;
for (int i = 0; i < n; i++,it++)
pBuff[m] = srcDate[i];
len = len + n;
}
template<class T>
void MyVector<T>::insert(Myiterator &pos, Myiterator begin, Myiterator end) //在指定位置插入一段容器里的数据
{
int n = end - begin;
if (n <= 0) //先后关系反了或者没有元素，不插入
return;
int t = len + n; //可能元素很多，需要放大多次，利用flag，一次性拷贝，稍微快一点传输数据，不然放大一次拷贝一次
bool flag = false;
while (t > Mlen)
{
Mlen = Mlen + ((Mlen >> 1) > 1 ? (Mlen >> 1) : 1);
flag = true;
}
if (flag) //改变容器容量
{
T *tempBuff = new T[Mlen];
int m = pos.p - pBuff; //m记录插入位置
if (m > len)
m = len;
memcpy(tempBuff, pBuff, sizeof(T)*m); //拷贝前半部分数据
Myiterator temp;
temp = begin;
for (int i = 0; i < n; i++,temp++) //拷贝容器里的数据
tempBuff[m + i] = *temp;
memcpy(tempBuff + m + n, pBuff + m, sizeof(T)*(len - m)); //拷贝后半部分数据
delete[] pBuff;
pBuff = tempBuff;
len = len + n; //别忘了改变元素个数
return;
}
//下面是没有改变容器容量，没用else可能不太显眼
int m = pos.p - pBuff;
if (m>len)
m = len;
for (int i = 0; i < n; i++)
pBuff[len + n - 1 - i] = pBuff[len - 1 - i]; //最后一个元素的位置（结尾）len+需要插入的元素个数n-前一个位置1-计数器i
Myiterator it = pos;
Myiterator it2 = begin;
for (int i = 0; i < n; i++, it++,it2++)
pBuff[m] = *it2;
len = len +n;
}
template<class T>
T MyVector<T>::pop_back() //stl 不返回，不检查，单独扔掉最后一个元素，我没那么做，反正void类型的话 只能单独，最后一个元素万一还有点用途，需要两个代码调用和删除
{
T temp = pBuff[len - 1]; //动态数组的末尾删除
len--;
return temp;
}
template<class T>
void MyVector<T>::push_back(T const &srcDate) //还是void合适,毕竟是压入一个数据，这个数据应该是有地方保存的，如果是一个一次性的常量，那就两行吧
{
if (len >= Mlen) //确认空间容量问题
{
Mlen = Mlen + ((Mlen >> 1) > 1 ? (Mlen >> 1) : 1);
T *tempBuff = new[Mlen];
memcpy(tempBuff, pBuff, sizeof(T)*len);
if (pBuff)
delete[] pBuff;
pBuff = tempBuff;
}
pBuff[len] = srcDate; //动态数组的末尾插入，末尾位置len，注意逾尾
len++;
}
template<class T>
typename MyVector<T>::Myiterator rbegin() //方便智能指针定位，逆向排列的第一个，即正数最后一个元素
{
Myiterator it;
it.p = pBuff[len - 1];
return it;
}
template<class T>
typename MyVector<T>::Myiterator rend() //方便智能指针定位，逆向排列的最后一个，即正数第一个元素，但是由于要逾尾，需要-1
{
Myiterator it;
it = pBuff - 1;
return it;
}
template<class T>
void MyVector<T>::reserve(size_t M) //只改变容器容量大小，其他不变
{
if (Mlen >= M) //就怕0 给的空间太小不变，-是为了防止两个0， 空容器和0大小
return;
Mlen = M;
T *temp = new T[Mlen];
if (pBuff)
{
memcpy(temp, pBuff, sizeof(T)*len);
delete[] pBuff;
}
pBuff = temp;
}
template<class T>
void MyVector<T>::resize(size_t n) //改变元素个数
{
if (len >= n) //需要前n个元素，n后面的元素舍去
{
len = n;
return;
}
if (n > Mlen) //需要n个元素，太多了，这个扩展容量的代码又重复了一遍
{
Mlen = Mlen + ((Mlen >> 1) > 1 ? (Mlen >> 1) : 1);
T *tempBuff = new[Mlen]();
memcpy(tempBuff, pBuff, sizeof(T)*len);
if (pBuff)
delete[] pBuff;
pBuff = tempBuff;
return;
}
//不需要扩大容量 len < n < Mlen
for (int i = len; i < n; i++) //多出去的元素补0
pBuff[i] = 0;
}
template<class T>
void MyVector<T>::swap(MyVector &temp) //和一个容器进行交换
{
MyVector t;
t.len = len;
t.Mlen = Mlen;
t.pBuff = pBuff;
len = temp.len;
Mlen = temp.Mlen;
pBuff = temp.pBuff;
temp.len = t.len;
temp.Mlen = t.Mlen;
temp.pBuff = t.pBuff;
t.pBuff = NULL; //这是一个可怕的事情，如果没有这个，交换后确实地址交换了，t和temp指向同一个位置，但是由于t在栈区，函数调用完即消失，t调用析构，然后temp就指向了一个不存在的地址
}
template<class T>
void MyVector<T>::swap(Myiterator begin, Myiterator end) //必须等容量，不等容量的话，那个交换会改变另一个容器的成员变量，需要多一个参数用以获得容器位置
{
int t = end - begin;
if (t!=len)
return;
Myiterator it = begin;
int m;
for (int i = 0; i < len; i++)
{
m = pBuff[i];
pBuff[i] = *it;
*it = m;
it++;
}
}
template<class T>
void MyVector<T>::swap(MyVector &dest, Myiterator begin, Myiterator end) //这个可以不写，然而真的不太想写，然后就犯懒吧
{
//犯懒了，直接使用一段删除和一段插入
if (end - begin <= 0) //智能指针反了
return;
MyVector<T> temp(begin, end); //把目标位置的东西取出来
dest.erase(begin, end);
if (pBuff) //在目标位置插入这边的元素
{
dest.insert(begin, pBuff);
delete[] pBuff;
}
pBuff = temp.pBuff; //把目标位置的元素拷过来
len = end - begin;
Mlen = end - begin;
temp.pBuff = NULL; //同上面的交换问题
}
// 容器大小关系的判断，前提要求，元素可以比大小。
template <class T>
bool MyVector<T>::operator !=(MyVector const & srcVector) const //容器比大小，是否是同一个容器
{
return !(*this == srcVector);
}
template <class T>
bool MyVector<T>::operator ==(MyVector const & srcVector) const
{
if (num == srcVector.num)
{
for (size_t i = 0; i < num; ++i)
{
if (pBuff[i] != srcVector.pBuff[i])
return false;
}
return true;
}
return false;
}
//容器大小关系的判断，前提要求，元素可以比大小。如果元素个数不同，直接出结果，元素多的大，如果元素个数一样，开始进行依次比较，直到比出大小，数大的/ascii码大的大，具体看T的类型
template <class T>
bool MyVector<T>::operator >(MyVector const &sreVector)const
{
if (num > sreVector.num)
return true;
if (num < sreVector.num)
return false;
for (size_t i = 0; i < num; ++i)
{
if (pBuff[i] > srcVector.pBuff[i])
return true;
if (pBuff[i] < srcVector.pBuff[i])
return false;
}
return false;
}
template <class T>
bool MyVector<T>::operator <(MyVector const &sreVector)const
{
if (num > sreVector.num)
return false;
if (num < sreVector.num)
return true;
for (size_t i = 0; i < num; ++i)
{
if (pBuff[i] > srcVector.pBuff[i])
return false;
if (pBuff[i] < srcVector.pBuff[i])
return true;
}
return true;
}
template <class T>
bool MyVector<T>::operator >=(MyVector const &sreVector)const
{
if (num > sreVector.num)
return true;
if (num < sreVector.num)
return false;
for (size_t i = 0; i < num; ++i)
{
if (pBuff[i] > srcVector.pBuff[i])
return true;
if (pBuff[i] < srcVector.pBuff[i])
return false;
}
return true;
}
template <class T>
bool MyVector<T>::operator <=(MyVector const &sreVector)const
{
if (num > sreVector.num)
return false;
if (num < sreVector.num)
return true;
for (size_t i = 0; i < num; ++i)
{
if (pBuff[i] > srcVector.pBuff[i])
return false;
if (pBuff[i] < srcVector.pBuff[i])
return true;
}
return true;
}
//容器的复制
template <class T>
void MyVector<T>::operator =(MyVector const &sreVector)const
{
if (pBuff)
delete[] pBuff;
num = sreVector.num;
maxNum = sreVector.maxNum;
pBuff = new T[num];
memcpy(pBuff, sreVector.pBuff, sizeof(T)* num);
}
以下可以不看
stdafx.h 用于部分头文件
// stdafx.h : 标准系统包含文件的包含文件，
// 或是经常使用但不常更改的
// 特定于项目的包含文件
//
#pragma once
#include "targetver.h"
#include <stdio.h>
#include <tchar.h>
#include"MyVector.h"
#include<iostream>
#include<vector>
using namespace std;
// TODO: 在此处引用程序需要的其他头文件
主程
// MyVector.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
int _tmain(int argc, _TCHAR* argv[])
{
MyVector<int> a1;
MyVector<int> a2(10);
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
MyVector<int> a3(a, 7);
MyVector<int> a4(5,6);
MyVector<int> a5(a3);
MyVector<int>::Myiterator it1;
MyVector<int>::Myiterator it2;
it1 = a3.begin();
it2 = a3.end()-3;
MyVector<int> a6(it1, it2);
a1.assign(4, 10);
++it1;
a2.assign(it1, it2);
a3.assign(a, 4, 10);
it1 = a3.begin();
printf("%d\n", a3.at(3));
a4.clear();
it1 = a3.begin() + 4;
it2 = a3.end() + 5;
//for (int i = 0; i < 5; i++)
// a3.erase(it1);
a3.erase(it1, it2);
a3.insert(it1, 2);
a3.insert(it1, a, 10);
it1 = a3.begin();
it2 = a3.begin()+5;
MyVector<int>::Myiterator it3;
it3 = a5.begin();
a5.insert(it3, it1, it2);
printf("%d\n", a5.pop_back());
a3.swap(a5);
return 0;
}
版权声明：本文为qq_40488600原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。