STL  == 》vector的部分现

vector类模板

template<typename T>
class Cvector
{
public://公有方法
typedef T value_type;//类型的萃取
Cvector() //vector构造函数不开辟内存
:mpvec(NULL),msize(0),mcur(0)
{
mpvec = NULL;
msize = 0;
mcur = 0;
}

//析构函数，开辟的是个数组，所以delete[];
~Cvector()
{
delete []mpvec;
mpvec = NULL;
}
Cvector(int size,const T &val = T())//带有参数的构造函数
:msize(size),mcur(size)
{
mpvec = new T[size];
msize = size;
mcur = 0;
for (int i =0;i<size;i++)
{
mpvec[i] = val;
}
}
vector有两种插入元素的方法，一种是尾插push_back，一种是inset按位置插入，在这里实现了尾插
void push_back(const T &val)//插入元素
{
if(full())
{
resize();
}
mpvec[mcur++] = val;
}
void pop_back()//删除元素
{
if (empty())
{
return ;
}
mcur--;
}
T& operator[](int index)//[]运算符的重载
{
return mpvec[index];
}
int size()const{return mcur;}//vector 当前所使用的数组的大小
bool empty()const{return mcur==0;}//判断是否为空
bool full() //判断是否为满
{
return mcur == msize;

}

class iterator//自己实现的迭代器
{//根据使用迭代器时所需要的然后写出它的成员方法
public:
typedef T value_type;
iterator(T *ptr,int pos)
{
mit = ptr +pos;

}
void operator++()
{
mit++;
}

bool operator!=(const iterator &src)
{
return mit != src.mit;
}
T &operator *()
{
return *mit;
}
iterator operator+(int size)
{
return iterator(mit+size,0);
}
iterator operator-(int size)
{
return iterator(mit-size,0);
}

private:
T *mit;
};

iterator begin()
{
return iterator(mpvec,0);
}
iterator end()
{
return iterator(mpvec,mcur);
}

private://成员变量

T *mpvec;//指针指向一个数组
int msize;//数组的总大小

int mcur;//当前所用的大小

void resize()//当数组满了之后自己将数组的大小放大至二倍

{
if (mpvec = NULL)
{
mpvec = new T[1];
msize = 1;
mcur =0;
}
else
{
T *ptmp = new T[msize*2];
memcpy(ptmp,mpvec,sizeof(T)*mcur);
delete []mpvec;
mpvec = ptmp;

}

}
Cvector<T>& operator=(const Cvector<T>&src);
Cvector(const Cvector<T>&src);
};

//自己实现的打印函数模板

template<typename Container>
void showContainer(Container &con)
{
Container::iterator it = con.begin();
for (;it != con.end();++it)
{
cout<< *it <<" ";
}
cout<<endl;
}

//排序函数，最后一个参数是函数指针，但是调用函数的时候开销太大不建议使用
template<typename InputIterator>
void mysort(InputIterator first,InputIterator last
,bool (*pfunc)(typename InputIterator::value_type,
typename InputIterator::value_type))
{
typedef InputIterator::value_type T;
InputIterator it1 = first;
InputIterator it2 = first;
int k=0;
for (;it1 != last;++it1,++k)
{
for (it2 = first;it2!=last-1-k;++it2)
{

if (*it2 > *(it2+1))
{
T tmp = *it2;
*it2 = *(it2+1);
*(it2+1) = tmp;

}
}
}

}
template<typename T>
bool _greater(T a,T b)
{
return a>b;
}
template<typename T>
bool _less(T a,T b)
{
return a<b;
}

//sort函数的第二个版本
template<typename InputIterator,typename Compare>
void mysort(InputIterator first,InputIterator last
,Compare &comp)
{
typedef InputIterator::value_type T;
InputIterator it1 = first;
InputIterator it2 = first;
int k=0;
for (;it1 != last;++it1,++k)
{
for (it2 = first;it2!=last-1-k;++it2)
{

if (*it2 > *(it2+1))
{
T tmp = *it2;
*it2 = *(it2+1);
*(it2+1) = tmp;

}
}
}

}

template<typename T>
class Mygreater
{
public:
bool operator()(T a,T b)
{
return a>b;
}

};
template<typename T>
class Myless
{
public:
bool operator()(T a,T b)
{
return a<b;
}
};

//自己实现的myfind_if函数
template<typename InputIterator,typename Compare>
InputIterator myfind_if(InputIterator first,InputIterator last
,Compare &comp)
{

for (;first!=last;++first)
{
if (comp(*first))
{
return first;
}
}
return last;

}

template<typename T>
class My_mless
{
public:
My_mless(T Val = T()):val(Val){}
bool operator()(T a)
{
return a<val;
}
private:
T val;
};

//mycopy函数
template<typename InputIterator, typename OutputIterator>
void mycopy(InputIterator first, InputIterator last,
OutputIterator dest)
{
InputIterator it = first;
for (; it != last; ++first)
{
*dest = *it;
++dest;
}
}

//插入型迭代器
template<typename Container>
class myback_insert_iterator
{
public:
typedef typename Container::value_type T;
myback_insert_iterator(Container &Con):con(Con){}
void operator=(const T&val)
{
con.push_back(val);

}
myback_insert_iterator<Container>& operator*()
{
return *this;
}
myback_insert_iterator<Container>& operator++()
{
return *this;
}

private:
Container &con;
};

template<typename Container>
myback_insert_iterator<Container>myback_insert(Container &com)
{
return myback_insert_iterator<Container>(com);
}

template<typename Container>
class myback_front_iterator
{
public:
typedef typename Container::value_type T;
myback_front_iterator(Container &Con):con(Con){}
void operator=(const T&val)
{
con.push_front(val);

}
myback_front_iterator<Container>& operator*()
{
return *this;
}
myback_front_iterator<Container>& operator++()
{
return *this;
}

private:
Container &con;
};

template<typename Container>
myback_insert_iterator<Container>myfront_insert(Container &com)
{
return myback_front_iterator<Container>(com);
}

自己实现了一个myfind函数模板

参数给定两个迭代器，用迭代器遍历容器，找到val以后返回val当前所处的迭代器，找不到返回first

template<typename InputIterator,typename T>
InputIterator myfind(InputIterator first,InputIterator last,const T &val)
{

for (;first != last;++first)
{
if (*first == val)
{
return first;
}

}
return last;
}

STL部分的实现