STL标准模板库（二）

1、set插入判断

//判断插入成功与否
void func1()
{
    set<int> s;
    s.insert(1);

    //插入的返回值
    pair<set<int>::iterator,bool> ret = s.insert(1);
    if(ret.second)
        cout<<"插入成功："<<*(ret.first)<<endl;
    else
         cout<<"插入失败!"<<endl;
    ret = s.insert(2);
    if(ret.second)
        cout<<"插入成功："<<*(ret.first)<<endl;
    else
         cout<<"插入失败!"<<en

2、set查找

//查找
void func2()
{
    set<int> s;
    s.insert(2);
    s.insert(3);
    s.insert(5);
    s.insert(7);
    s.insert(9);

    //1、成功返回找到元素的位置的迭代器，失败返回end()
    set<int>::iterator ret = s.find(3);
    if(ret != s.end())
        cout<<"find:找到元素："<<*ret<<endl;
    else
        cout<<"元素不存在"<<endl;
    ret = s.find(11);
    if(ret != s.end())
        cout<<"find:找到元素："<<*ret<<endl;
    else
        cout<<"元素不存在"<<endl;

    //2、返回值是一个>=当前元素的迭代器
    set<int>::iterator ret1 = s.lower_bound(3);
    if(ret1 != s.end())
        cout<<"lower_bound:找到元素："<<*ret1<<endl;
    else
        cout<<"元素不存在"<<endl;
     ret1 = s.lower_bound(4);
     if(ret1 != s.end())
         cout<<"lower_bound:找到元素："<<*ret1<<endl;
     else
         cout<<"元素不存在"<<endl;
     ret1 = s.lower_bound(15);
     if(ret1 != s.end())
         cout<<"lower_bound:找到元素："<<*ret1<<endl;
     else
         cout<<"元素不存在"<<endl;
     //3、返回值是一个>当前元素的迭代器
     set<int>::iterator ret2 = s.upper_bound(3);
     if(ret2 != s.end())
         cout<<"upper_bound:找到元素："<<*ret2<<endl;
     else
         cout<<"元素不存在"<<endl;
      ret2 = s.upper_bound(2);
      if(ret2 != s.end())
          cout<<"upper_bound:找到元素："<<*ret2<<endl;
      else
          cout<<"元素不存在"<<endl;
      ret2 = s.upper_bound(15);
      if(ret2 != s.end())
          cout<<"找到元素："<<*ret2<<endl;
      else
          cout<<"元素不存在"<<endl;
      //4、第一个元素---->lower_bound
      //第二个元素---->upper_bound
      pair<set<int>::iterator,set<int>::iterator>ret3 = s.equal_range(3);
      if(ret3.first != s.end())
          cout<<"找到元素："<<*ret3.first<<endl;
      if(ret3.second != s.end())
          cout<<"找到大于该元素的下一个元素："<<*ret3.second<<endl;
}

3、multiset

//multset--->允许插入相同的元素
void func3()
{
    multiset<int> m;
    m.insert(1);
    m.insert(2);
    m.insert(2);
    m.insert(2);
    m.insert(4);
    m.insert(7);

    // 查找multset中所以2 的元素
    pair<multiset<int>::iterator,multiset<int>::iterator> ret = m.equal_range(2);
    while(ret.first != ret.second)
    {
        cout<<*ret.first<<endl;
        ret.first++;
    }

4、map

#include <iostream>
#include <map>
#include <string>

using namespace std;

void print(map<int,string> &m)
{
    map<int,string>::iterator it = m.begin();
    while(it != m.end())
    {
        cout<<"id = "<<it->first<<",name = "<<it->second<<endl;
        it++;
    }
}

//map--->键值对
void func1()
{
    map<int,string> m;
    //插入方式1--->用pair对组
    m.insert(pair<int,string>(5,"小白5"));
    print(m);

    cout<<"--------------------------------"<<endl;
    //插入方式2--->make_pair
    m.insert(make_pair(2,"小白2"));
    print(m);

    cout<<"--------------------------------"<<endl;
    //插入方式3--->value_type
    m.insert(map<int,string>::value_type(4,"小白4"));
    print(m);

    cout<<"--------------------------------"<<endl;
    //插入方式4---->[键] = 值;(不建议 使用这种方式，如果数据已经存在会覆盖原来的值，不存在就写入新的数据)
    //[]--->运算符重载-->中间的元素可以是任意类型不是只能整型数据
    m[1] = "小白2";
    print(m);
}

//multimap--->允许键相同
void func2()
{
    multimap<int ,string> mp;
    mp.insert(make_pair(2,"小白2"));
    mp.insert(make_pair(2,"小白2"));
    mp.insert(make_pair(2,"小白2"));
    mp.insert(make_pair(2,"小白2"));
    mp.insert(make_pair(2,"小白2"));
    multimap<int,string>::iterator it = mp.begin();
    while(it != mp.end())
    {
        cout<<"id = "<<it->first<<",name = "<<it->second<<endl;
        it++;
    }
}

int main()
{
    //func1();
    func2();

    return 0;
}

5、谓词

谓词，返回值是bool类型的函数对象—用于判断

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

//打印
void print1(int a)//函数
{
     cout<< a <<endl;
}

bool test(int a)
{
    return a>3;
}

class Test//谓词，返回值是bool类型的函数对象---用于判断
{
public:
    Test(int num)
    {
        this->num = num;
    }

    bool operator()(int a)
    {
        return (a%num == 0);
    }
private:
    int num;
};

class Compe
{
public:
    bool operator()(int a,int b)
    {
        //return a>b;     //从大到小
        return a<b;       //从小到大
    }
};

//一元谓词
void func11()
{
    vector<int> v;
    for(int i = 0;i < 10;i++)
        v.push_back(i);
    int ret = count_if(v.begin(),v.end(),test);
    cout <<">3 的元素个数："<<ret<<endl;
    ret = count_if(v.begin(),v.end(),Test(3));
    cout <<"因数是3的元素个数："<<ret<<endl;

    vector<int>::iterator it = find_if(v.begin(),v.end(),test);
    cout <<"第一个大于3的 数"<< *it <<endl;
}

//二元谓词
void func22()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(4);
    v.push_back(2);
    v.push_back(6);
    v.push_back(3);

    sort(v.begin(),v.end(),Compe());
    for_each(v.begin(),v.end(),print1);
}

int main4()
{
    func11();
    //func22();

    return 0;
}

6、预定义函数对象&&适配器

//预定义函数对象--->函数写好的对象
头文件：#include <functional>
//函数适配器
1、绑定器：通过将二元函数对象的某个参数设置成一个固定的值从而将对象改为一元函数
 1.1 bind1st(函数对象，值) 将值绑定到函数对象的第一个参数上
 1.2 bind2nd(函数对象，值) 将值绑定到函数对象的第二个参数上
2、取反器
 2.1 not1--->对一元函数对象的值进行取反
 2.2 not2--->对二元函数对象的值进行取反


#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <string>

using namespace std;

//预定义函数对象--->函数写好的对象
void func111()
{
    plus<int> add;   //函数对象
    cout<<"1+2"<<add(1,2)<<endl;
    greater<string> gt;
    cout<< gt("asdfsf","adsad")<<endl;

    vector<int> v;
    v.push_back(2);
    v.push_back(3);
    v.push_back(6);
    v.push_back(4);
    v.push_back(7);
    v.push_back(1);
    v.push_back(8);
    v.push_back(5);
    v.push_back(9);

    sort(v.begin(),v.end(),greater<int>());

    //函数适配器
    //绑定器：通过将二元函数对象的某个参数设置成一个固定的值
    //从而将对象改为一元函数
    //bind1st(函数对象，值) 将值绑定到函数对象的第一个参数上
    //bind2nd(函数对象，值) 将值绑定到函数对象的第二个参数上
    //统计大于3的个数
    int ret = count_if(v.begin(),v.end(),bind1st(less<int>(),3));
    cout <<"大于3的个数"<<ret <<endl;
    ret = count_if(v.begin(),v.end(),bind2nd(greater<int>(),3));
    cout <<"大于3的个数"<<ret <<endl;

    //取反器
    //not1--->对一元函数对象的值进行取反
    //not2--->对二元函数对象的值进行取反
    //能被2整除的数
    ret = count_if(v.begin(),v.end(),not1(bind2nd(modulus<int>(),2)));
    cout << "能被2整除的数" <<ret<<endl;
}

int main()
{
    func111();

    return 0;
}