STL的部分实现

//vector   
template<typename T>
class CVector
{
public:
CVector()    //不开辟内存
:mpvec(NULL),msize(0),mcur(0){}
CVector(int size, const T &val=T())
:msize(size),mcur(size)
{
mpvec = new T[msize];
}
~CVector()
{
delete []mpvec;
mpvec = NULL;
}

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;}
bool empty()const{return mcur == 0;}
bool full()const{return mcur == msize;}
class iterator
{
public:
typedef T value_type;       // iterator::value_type;
iterator(T *ptr, int pos=0)
{
mpcur = ptr+pos;
}
bool operator!=(const iterator &it)
{
return mpcur!=it.mpcur;
}
void operator++()
{
mpcur++;
}
T& operator*()
{
return *mpcur;
}
iterator operator-(int size)
{
return iterator(mpcur-size);
}
iterator operator+(int size)
{
return iterator(mpcur+size);
}
private:
T *mpcur;
};
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);
msize*=2;
delete []mpvec;
mpvec = ptmp;
}
}


CVector(const CVector<T>&);
CVector<T>& operator=(const CVector<T>&);
};
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)
{
typedef InputIterator::value_type T;
//冒泡排序
InputIterator iti = first;
InputIterator itj = first;
int k=0;


for(; iti != last; ++iti, ++k)
{ //iterator operator-(int size)
for(itj=first; itj!=last-1-k; ++itj)
{ //iterator operator+(int size)
if(*itj > *(itj+1)) //函数指针   =》    inline  xxxx
{
//交换  萃取模板的类型  typedef
T temp = *itj;
*itj = *(itj+1);
*(itj+1) = temp;
}
}
}
}


/*
实现mygreater myless类


mysort();
*/
template<typename InputIterator, typename Compare>
void mysort(InputIterator first, InputIterator last,
Compare &comp)
{
typedef InputIterator::value_type T;
//冒泡排序
InputIterator iti = first;
InputIterator itj = first;
int k=0;


for(; iti != last; ++iti, ++k)
{ //iterator operator-(int size)
for(itj=first; itj!=last-1-k; ++itj)
{ //iterator operator+(int size)
//comp.operator()(*itj, *(itj+1))
// 二元函数对象    一元函数对象
if(comp(*itj, *(itj+1)))
{
//交换  萃取模板的类型  typedef
T temp = *itj;
*itj = *(itj+1);
*(itj+1) = temp;
}
}
}
}
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;
}
//comp => 一元的函数对象operator()(T a) ？   二元的函数的函数对象？
template<typename InputIterator, typename Compare>
InputIterator myfind_if(InputIterator first, InputIterator last,
Compare &comp)
{
for(; first != last; ++first)
{
if(comp(*first))  // comp.operator()(*first)
return first;
}
return last;
}


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

}
}

//less的实现
template<typename T>
class _myless
{
public:
_myless(T data=T()):_value(data){}
bool operator()(T a)
{
return a<_value;
}
private:
T _value;
};

//greater的实现
template<typename T>
class mygreater
{
public:
bool operator()(T a, T b)    // bind1st  mygreater
{
return a>b;
}
};
template<typename T>
class myless
{
public:
bool operator()(T a, T b)   //  bind2nd  myless   
{
return a<b;
}
};

//绑定器的实现
template<typename Compare, typename T>
class _mybind1st
{
public:
typedef T value_type;    //_mybind1st::value_type
_mybind1st(Compare &comp, T val)
:_comp(comp), _val(val){}
bool operator()(T a)   // *first
{
return _comp(_val, a);
}
private:
Compare &_comp;
T _val;
};
// 1.帮助函数对象自动推到模板类型   2.封装了函数对象的创建
template<typename Compare, typename T>
_mybind1st<Compare, T>  mybind1st(Compare &comp, const T &val)
{
return _mybind1st<Compare, T>(comp, val);
}
/*
CVector<int>::iterator it2=myfind_if(vec.begin(), 
vec.end(), mybind1st(mygreater<int>(), 60));
  _mybind1st<Compare, T>(mygreater<int>(), 60)
*/
template<typename Compare>
class _mynot1
{
public:
typedef typename Compare::value_type T;
_mynot1(Compare &comp):_comp(comp){}
//template<typename T>
//类型萃取
bool operator()(T a)      // comp(*first)
{
return !_comp(a);
}


private:
Compare &_comp;
};
template<typename Compare>
_mynot1<Compare> mynot1(Compare &comp)
{
return _mynot1<Compare>(comp);
}


// *dest++ = *first;    


//*dest = *first;
//dest++;


/*template<typename Container>
class _myback_inserter    // 给容器添加元素    container.push_back(val);
{
public:
private:
};
template<typename Container>
迭代器类型 myback_inserter(Container &con)
{
return 一个迭代器;

}

template<typename T>
inline bool _greater(T a, T b)
{
return a>b;
}
template<typename T>
inline bool _less(T a, T b)
{
return a<b;
}
//mysort(vec.begin(), vec.end(), xxx);
//泛型算法   =    模板 + 迭代器 + 函数对象
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 iti = first;
InputIterator itj = first;
int k=0;


for(; iti != last; ++iti, ++k)
{ //iterator operator-(int size)
for(itj=first; itj!=last-1-k; ++itj)
{ //iterator operator+(int size)
// 函数指针调用函数   函数名调用函数   效率???
if(pfunc(*itj, *(itj+1)))
{
//交换  萃取模板的类型  typedef
T temp = *itj;
*itj = *(itj+1);
*(itj+1) = temp;
}
}
}
}