C++ STL

STL（Standard Template Liblrary），标准模板库。
一、顺序容器

vector

内存分配由allocator完成。

int main()
{
    vector<int> vec1;
    if(vec1.empty())
    {
        cout<<"vec1 is empty"<<endl;
    }
    vec1.push_back(1);
    vec1.push_back(22);
    vec1.push_back(5);
    vec1.push_back(65);
    vec1.push_back(7);

    sort(vec1.begin(),vec1.end());

    vector<int>::iterator it = vec1.begin();
    for(; it!=vec1.end(); ++it)
    {
        cout<<*it<<" ";
    }
    cout<<endl;

    it = find(vec1.begin(),vec1.end(),5);
    if(it == vec1.end())
    {
        return -1;
    }

    vec1.erase(it);
    //erase();删除一个或几个元素，传入一个迭代器进去
    //clear();清除容器中所有元素

    vec1.insert(it,99);
    //容器里面有元素改动时，迭代器就失效了
    //在某位置增加/删除元素，该位置之后的所有迭代器失效
    //对于扩容的情况，所有迭代器都失效（已经不是原来的内存了）

    sort(vec1.begin(),vec1.end(),greater<int>());
    //传入一个函数对象改变其排序方式
    //greater<int>()降序排列；less<int>()升序

    it = find_if(vec1.begin(),vec1.end(),bind1st(greater<int>(),50));
    //find_if有条件的查找
    //绑定器bind1st();bind2nd();
    if(it == vec1.end())
        return -1;

    cout<<*it<<endl;

    for(it=vec1.begin(); it!=vec1.end(); ++it)
    {
        cout<<*it<<" ";
    }
    cout<<endl;

    vector<int> vec2;
    //vec2.swap(vec1);
    copy(vec1.begin(),vec1.end(),vec2.begin());//
    //copy(vec1.begin(),vec1.end(),inserter(vec2,vec2.begin()));
    for(it=vec2.begin(); it!=vec2.end(); ++it)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
    return 0;
}

deque

二、关联容器
增、删、查、改时间复杂度都是log以2为底n的对数

int main()
{
    /*
    set<int> myset;
    for(int i = 0; i<10; ++i)
    {
        myset.insert(rand()%100);
    }
    copy(myset.begin(),myset.end(),ostream_iterator<int>(cout," "));
    //红黑树本身就有序
    cout<<endl;
    set<int>::iterator it = myset.find(51);
    if(it == myset.end())
        return -1;
    cout<<*it<<endl;

    cout<<myset.count(5)<<endl;
    */
    map<string,string> map1;
    map1.insert(make_pair("101","zhang"));
    map1.insert(make_pair("102","wamh"));
    map1.insert(make_pair("103","li"));
    map1.insert(make_pair("104","zhao"));

    map1["104"] = "wu";

    map<string,string>::iterator it = map1.find("101");
    if(it == map1.end())
    {
        return -1;
    }
    cout<<"key:"<<it->first<<" val:"<<it->second<<endl;

    return 0;
}

三、容器适配器
所谓容器适配器就是对已有容器的一种封装，底层并没有自己的数据结构。stack和queue底层是deque，priority_queue插入元素时，是自动按优先级顺序插入，使最高优先级元素首先从优先级对列中取出，其以vector为基础数据结构。

四、泛型算法
修改容器的算法，即变化序列算法：copy()、 remove()、 replace() 、 swap()等。
不修改容器的算法，即非变化序列算法：count() 、find()等。

五、迭代器





反转型迭代器reserve_iterator

插入型迭代器
bake_insert_iterator：将元素添加到类型为T的容器对象的末端；
front_insert_iterator：将元素添加到类型为T的容器对象的前端；
insert_iterator

int main()
{
    /*
    vector<int> vec;
    for(int i = 0; i < 20; ++i)
    {
        vec.push_back(rand()%100);
    }
    copy(vec.begin(),vec.end(),ostream_iterator<int>(cout," "));
    */
    vector<int> vec;
    copy(istream_iterator<int>(cin),
        istream_iterator<int>(),//一个无效的流，表示流结束
        back_inserter(vec));
    sort(vec.begin(),vec.end());
    copy(vec.begin(),vec.end(),ostream_iterator<int>(cout," "));
    return 0;
}

常量迭代器

vector<int>::const_iterator it = vec.begin();
//const修饰所指的元素，不能解引用修改其值
const vector<int>::iterator it = vec.begin();
//修饰iterator，即it，其指向不能变

六、函数对象/仿函数
函数对象是一个类，它重载了函数调用操作符（operator()）。
函数对象与函数指针相比较有三个优点：第一，函数指针是间接引用，不能作为内联函数，而函数对象可以，这样速度更快；第二，函数对象可以拥有任意数量的额外数据，用这些数据可以用来缓冲当前数据和结果，提高运行质量，当然多数情况下不一定使用；第三，编译时对函数对象作类型检查。

逻辑函数对象，这里Type必须支持逻辑运算，有两个参数。
逻辑与：logical_and //对应&&
逻辑或：logical_or //对应||
逻辑非：logical_not //对应!
关系函数对象，它们的返回值为布尔量，两个参数，第一参数和第二参数相比：
等于：equal_to
不等于：not_equal_to
大于：greater
大于等于：greater_equal
小于：less
小于等于：less_equal
返回布尔值的函数对象称为谓词（predicate），默认的二进制谓词是小于比较操作符“<”，所以默认的排序方式都是升序排列，它采用小于比较形式。

七、绑定器
1．绑定器（binder）：把二元函数对象中的一个参数固定（绑定），使之转为一元函数，C++标准库提供两种预定义的binder适配器：bind1st和bind2nd，分别绑定了第一或第二个参数。
2．取反器（negator）：把函数对象的值翻转的适配器，如原来为小于，用了它后就变成了大于。C++标准库也提供了两种negator适配器：not1和not2。not1用于一元预定义函数对象；not2用于二元预定义函数对象。
所有泛型算法的前两个实参是一对iterator，通常称为first和last，它们标出要操作的容器或内置数组中的元素范围。元素的范围，包括first，但不包含last的左闭合区间。