STL中部分函数的实现

1.迭代器
普通迭代器：
Container::iterator it = con.begin();
常量迭代器：只能读不能修改 调用*元运算符重载，返回值为const。
Container::const_iterator it ;
而const Container::iterator it ; 并非常量迭代器。
1)正向常量迭代器
Container::const_iterator it; begin() end()
2）逆向常量迭代器
Container::const_reverse_iterator it; rbegin() rend()
3）插入型迭代器（给容器中添加元素）
4）流迭代器

2.泛型算法（排序，函数对象-括号运算符重载）
容器排序：一次从容器中取出两个数比较，那函数就是二元函数

自己实现STL库中函数：
find_if() 寻找匹配的条件，
bind1st() 绑定第一个参数，返回一个一元函数对象
bind2nd() 绑定第二个参数，返回一个一元函数对象
not1() 取反器 接收一个一元函数对象，返回一个一元函数对象
back_insert_iterator () 插入型迭代器（类模板）
copy() 将一个容器中的内容拷贝到另一个容器中
插入型迭代器（插入器）：


插入型迭代器常和copy配合使用。

实现代码：

#include<iostream>
//顺序容器  vector deque list
#include <vector>
#include<deque>
#include <list>
//关联容器  set multiset map multimap
#include <set>
#include<map>
//容器适配器  stack queue prior_queue
#include<stack>
#include<queue>
#include <iterator>
#include <functional>//函数对象
#include <algorithm>//泛型算法
using namespace std;

//遍历打印容器中的元素，通过[]运算符重载
template<typename Container>
void showContainer(const Container &con)
{
     for (int i=0;i<con.size();i++)
     {
         cout<<con[i]<<" ";
     }
     cout<<endl;
};
//遍历打印容器中的元素，通过迭代器
template<typename Container>
void show(const Container &con1)
{
    Container::const_reverse_iterator it=con1.rbegin();
    for( ; it != con1.rend();++it)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
}
//遍历打印容器中的元素，通过迭代器
template<typename Container>
void show2(const Container &con1)
{
    Container::const_iterator it=con1.begin();
    for( ; it != con1.end();++it)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
}

template<typename T>
class Cobj
{
public:
    Cobj(T value):mvalue(value){}
    bool operator()(T a)
    {
       return a > mvalue;
    }
private:
    T mvalue;
};
//my_find_if(）的实现
template<typename iterator,typename Compar>//Compar类类型
iterator my_find_if(iterator first,iterator last,Compar comp)//comp是类对象（函数对象）
{
    for ( ; first!= last;++first)
    {
        if(comp(*first))//comp这个对象调用它的括号运算符重载comp.operator()
            return first;
    }
    return last;
   cout<<endl;
}
//函数调用时，Cobj的构造函数生成一个对象，在for循环中该对象调用括号运算符重载
vector<int>::iterator                      it2=my_find_if(vec.begin(),vec.end(),Cobj<int>(40));

//由于我们之前实现的my_find_if只能接收一个参数，因此若传入两个参数时，可将第二个参数进行绑定 ，my_bind(）函数的实现 
template<typename compare ,typename T>
class _my_bind
{
public:
    _my_bind(compare &com,T val):comp(com),value(val){}
//这里的left是二元函数对象中的第一个参数，括号运算符的重载返回类型本身就是一个bool类型
    bool operator()(T left){return comp(left,value);}
private:
      compare &comp;
      T value;

};
template<typename compare,typename T >
_my_bind<compare,T> my_bind(compare comp,T val)
{
    return _my_bind<compare,T>(comp,val);//返回一个一元函数对象
}

//简洁版 代码更紧凑 my_bind()的实现  类型合并，类的继承关系
template<typename A1,typename A2,typename R>
class my_binary_function
{
public:
    typedef A1 fist_arg;
    typedef A2 second_arg;
    typedef R  return_type;
};

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

template<typename compare> //T 是compare作用域下的
class _my_bind
{
public:
    typedef typename compare::second_arg T;
    _my_bind(compare &com,T val):comp(com),value(val){}
    bool operator()(T left){return comp(left,value);}
private:
    compare &comp;
    T value;
};
template<typename compare>
_my_bind<compare> my_bind(compare comp,compare::second_arg value)
{
     return _my_bind<compare>(comp,value);
};
//这里的绑定器bind还是使用的是my_find_if中的括号运算符重载
//实例化vector<int>::iterator it3=my_find_if(vec.begin(),vec.end(),my_bind(greater<int>(),41));

//简洁版的my_left_bind  
template<typename A1,typename A2,typename R>//定义参数类型
class my_function
{
public:
    typedef A1 first_arg;
    typedef A2 second_arg;
    typedef R  return_type;
};

template<typename T>
class my_less:public my_function<T,T,bool>//二元函数类继承参数类型
{
public:
    bool operator()(T a,T b)
    {
       return a < b;
    }
};

template<typename Compare>//绑定第一个参数
class _my_left_bind
{
public:
    typedef typename Compare::second_arg T;
    _my_left_bind(Compare &com,T val):comp(com),value(val){}
    bool operator()(T right)
    {
        return comp(value,right);//调用的my_less括号运算符重载
    }
private:
    Compare &comp;
    T value;
};

template<typename Compare>
_my_left_bind<Compare> my_left_bind(Compare comp,typename Compare::first_arg val)
{
    return  _my_left_bind<Compare>(comp,val);//调用的_my_left_bind括号运算符重载
}

//将一个容器中的数据放入另一个容器中，只可用于赋值，更改元素，不能添加元素,copy(）函数的实现。
template<typename Inputiterator,typename Outiterator>
void my_copy(Inputiterator first,Inputiterator last,Outiterator dest)
{
    for ( ;first != last;++first)
    {
        *dest++=*first;
    }
}

// not1 not2 取反器
//not1是对一元函数取反，not2是对二元函数取反。
template<typename compare>
class _not1
{
public:
    typedef typename compare::first_arg T;//
    _not1(compare &com):comp(com){}
    bool operator()(T value){return !comp(value);}//对一元函数取反
private:
    compare comp;
    T value;
};
template<typename compare>
_not1<compare> my_not1(compare comp)
{
    return _not1<compare>(comp);
}
//函数的调用
vector<int>::iterator it4=my_find_if(vec.begin(),vec.end(),my_not1(bind1st(greater<int>(),41)));

/*
//插入型迭代器 可以给容器中添加元素，其本质就是调用的是Push_back

back_insert_iterator();
front_insert_iterator();
insert_iterator();
*/
//my_back_insert_iterator的实现
template<typename Container>
class my_back_insert_iterator//返回的是一个迭代器
{
public:
    typedef typename Container::value_type T;//value_type是库里面一个保存模板实例化类型的名字
    my_back_insert_iterator(Container &_con):con(_con){}
    my_back_insert_iterator& operator *(){return *this;}
    my_back_insert_iterator& operator ++(){return *this;}
    my_back_insert_iterator& operator++(int){return *this;}
    void operator=(const T &val)
    {
       con.push_back(val);  //调用容器本身的push_back()方法;
    }
private:
    Container &con;
};

template<typename Container>
my_back_insert_iterator<Container> my_back_inserter(Container &con)
{
    return my_back_insert_iterator<Container>(con);

}
int main()
{
    int array[20]={0};
    for (int i=0;i<20;++i)
    {
        array[i]=rand()%100+1;
    }

    vector<int>vec(array,array+20);

    //showContainer(vec);
    show2(vec);

    vector<int>::iterator it4=my_find_if(vec.begin(),vec.end(),my_not1(bind1st(greater<int>(),41)));
    if (it4 == vec.end())
    {
        exit(0);
    }
    vec.insert(it4,41);//insert是在迭代器之前插入一个元素
    show2(vec);



    /*list<int> mylist;
    my_back_insert_iterator<list<int>>backit(mylist);
        *backit=30;
        *backit=40;
        *back_inserter(mylist)=10;
        *back_inserter(mylist)=20;
    show2(mylist);*/


    //库中的类模板  back_insert_iterator
    //back_insert_iterator<list<int>>backit(mylist);
    //*backit=10;
    //*backit=20;
    库中的函数模板  back_inserter
    //back_inserter(mylist)=30;
    //back_inserter(mylist)=40;

    // show2(mylist);
    //sort(vec.begin(),vec.end());
    /*sort(vec.begin(),vec.end(),less<int>());
    showContainer(vec);*/

    /*sort(vec.begin(),vec.end(),greater<int>());
    showContainer(vec);*/

    //给容器中合适位置插入一个数
    /*vector<int>::iterator it2=find_if(vec.begin(),vec.end(),compare);//传入函数指针
    if (it2 == vec.end())
    {
        exit(0);
    }
    vec.insert(it2,40);
    showContainer(vec);*/

  //自己实现一元函数
    //vector<int>::iterator it2=my_find_if(vec.begin(),vec.end(),Cobj<int>(40));//传入对象
    //if (it2 == vec.end())
    //{
    //  exit(0);
    //}
    //vec.insert(it2,40);//insert是在迭代器之前插入一个元素
    //showContainer(vec);

    绑定第二个参数  自己实现的my_bind相当于库中的bind2nd
    //vector<int>::iterator it3=my_find_if(vec.begin(),vec.end(),my_bind(greater<int>(),41));
    //showContainer(vec);
    //if (it3 == vec.end())
    //{
    //  exit(0);
    //}
    //vec.insert(it3,41);//insert是在迭代器之前插入一个元素
    //showContainer(vec);
     //绑定第一个参数  自己实现的my_bind相当于库中的bind1st
    /*vector<int>::iterator it=my_find_if(vec.begin(),vec.end(),my_left_bind(my_less<int>(),41));
    showContainer(vec);
    if (it == vec.end())
    {
        exit(0);
    }
    vec.insert(it,41);
    showContainer(vec);*/
    //bind1st是绑定二元函数的第一个参数  bind2nd是绑定第二个参数，都是库提供的函数
    //当从大到小排序时，即调用greater时，41应该绑定在第2个参数  a >  41找到大于41的数在之前插入
    //当从小到大排序时，即调用less时，41应该绑定在第1个参数  41 > b找到大于41的数在之前插入
    //vector<int>::iterator it4=my_find_if(vec.begin(),vec.end(),bind2nd(greater<int>(),41));
    //vector<int>::iterator it4=my_find_if(vec.begin(),vec.end(),bind1st(less<int>(),41));
    //not1是给一元函数对象取反，not2是给二元函数对象取反（真变假，假变真）
    /*vector<int>::iterator it4=my_find_if(vec.begin(),vec.end(),not1(bind2nd(less<int>(),41)));*/


    return 0;
}


//容器的遍历
template<typename Container>
void ShowContainer2(const Container &Cont)
{
    //常量迭代器  只能读，不能更改
    //Container::const_iterator it; //const int *p  不能更改
    //const Container::iterator it   //int *const p  能修改
    cout<<"正向迭代"<<endl;
    Container::const_iterator it1=Cont.begin();
    for ( ; it1 != Cont.end();++it1)
    {
        cout<< *it1<<" ";
    }
    cout<<endl;

    cout<<"逆向迭代"<<endl;
    Container::const_reverse_iterator rit=Cont.rbegin();
    for ( ; rit != Cont.rend();++rit)
    {
        cout<< *rit<<" ";
    }
    cout<<endl;

}

//函数调用
int main()
{
    //通用的容器四种构造方式
    vector<int> vec1;
    showContainer(vec1);

    vector<int> vec2(10); 
    showContainer(vec2);

    vector<int> vec3(10, 20);
    showContainer(vec3);

    int array[] = { 12, 4, 56, 7, 89, 4, 32, 21 };
    vector<int> vec4(array, array+8);
    showContainer(vec4);
   /* vector<int> vec1;

    cout<<vec1.size()<<endl;
    cout<<vec1.max_size()<<endl;

    for (int i=1;i<9;i++)
    {
        vec1.push_back(i*10);//尾端插入
    }

    showContainer(vec1);

    vec1.pop_back();//尾端删除
    showContainer(vec1);

    vec1.insert(vec1.begin(),100);//首端位置处插入
    showContainer(vec1);
    if (vec1.empty())
    {
        cout<<"vec1 is empty"<<endl;
    }
    sort(vec1.begin(),vec1.end());//默认排序（从小到大）
    showContainer(vec1);

    sort(vec1.begin(),vec1.end(),greater<int>());//从大到小排序
    showContainer(vec1);

    sort(vec1.begin(),vec1.end(),less<int>());//从小到大排序
    showContainer(vec1);



    //找到第一个大于30的数删除它  需要用迭代器来遍历
    //第一种方法   
    vector<int>::iterator it=vec1.begin();  //每个容器有自己对应的迭代器
    for( ; it != vec1.end();++it )
    {
        if (*it > 30)
        {
            break;
        }
    }
    if (it == vec1.end())//没找到
    {
        exit(0);
    }
    //找到了
    vec1.erase(it);
    showContainer(vec1);

    //第二种方法   实现自己的my_find  借助函数对象Cpred


    vector<int>::iterator it2=my_findif(vec1.begin(),vec1.end(),compare);
    if (it2 == vec1.end())//没找到
    {
        exit(0);
    }
    //找到了
    vec1.erase(it2);
    ShowContainer2(vec1);


    return 0;
}*/

库中的sort（）函数只能用于底层内存连续的数据结构进行排序
不适用于list,而适用于vector 和deque。

当出现这种情况：

windowS 和 Linux: