重新学习《C++Primer5》第11章-关联容器

11.1 使用关联容器

void Chapter11In1()
{
/*vector和map的不同：vector相当于一个数组，采用顺序存储
    优点：不需要分配存储空间也可以向数组一个存取,并且可以动态操作，节省空间
    缺点：插入、删除操作效率低，添加只能在最后
    map由一个健值和一个映照数据一一对应关系组成，数据结构采用红黑树实现，健值不允许重复，比较元素只对健值比较
    list：采用链式存储，存储不连续，可在两端操作push，pop
    缺点：不支持[]取操作，相对vector占用内存多
    deque：综合了vector和list优缺点
    */
    string word;
    map<string,int> word_count;
    while(cin>>word)
    {
        transform(word.begin(),word.end(),word.begin(),tolower);
        for(string::size_type i=0;i!=word.size();i++)
        {
            if(ispunct(word[i]))
            {

                word.erase(i);
                i--;
            }
        }       
        word_count[word]++;     
    }
    for(map<string,int>::iterator it=word_count.begin();it!=word_count.end();it++)
    {
        cout<<it->first<<":"<<it->second<<endl;
    }
}

11.2 关联容器概述

1.multi允许重复

//11.2.1
void Chapter11In2To1()
{
    //map和set的区别：set是集合，不允许重复
    map<string,vector<string>> Famliy;
    int choose,count;
    string xm,na;
    vector<string> name;
    while(1)
    {
        cout<<"*   1:添加新的家庭   *"<<endl;
        cout<<"*   2:向已有家庭添加成员   *"<<endl;
        cin>>choose;
        switch(choose)
        {
        case 1:
            name.clear();
            cout<<"请输入家庭姓名和成员个数："<<endl;
            cin>>xm;
            cin>>count;
            cout<<"请输入成员名字："<<endl;
            for(int i=0;i<count;i++)
            {

                cin>>na;
                name.push_back(na);
            }
            Famliy[xm]=name;
            break;
        case 2:
            cout<<"请输入要添加的家庭姓名:"<<endl;
            cin>>xm;
            name=Famliy[xm];
            cout<<"请输入要添加的成员名字:"<<endl;
            cin>>na;
            name.push_back(na);
            Famliy[xm]=name;
            break;
        default:
            for(map<string,vector<string>>::iterator it=Famliy.begin();it!=Famliy.end();it++)
            {
                cout<<it->first<<":";
                for(int i=0;i!=it->second.size();i++)
                    cout<<it->second[i]<<" ";
                cout<<endl;
            }

            cout<<"输入错误，请重新输入"<<endl;
            continue;
        }
    }
}

2.传递给排序算法的可调用对象，必须满足与关联容器中关键字一样的类型要求

• 有序容器关键字类型
  自定义比较操作必须在关键字类型上定义一个严格弱排序，在实际编程中，如果一个类型定义了“行为正常”的<运算符，则它可以用作关键字类型。

multiset<Sales_data,decltype(compareIsbn*)>bookstore(compareIsbn);

3.pair类型

11.3关联容器操作

set<string>::vaule_type s1;
set<string>::key_type s2;//s1和s2都为string
map<string,int>::value_type v1;//v1是pair
map<string,int>::key_type v2;//v2是string
map<string,int>::mapped_type v3;//v3是int

11.3.1 关联容器迭代器

1.map的value_type是pair类型，可以改变pair的值，但不能改变关键字成员的值。

auto it=word_count.begin();
it->first="new key";//错误：关键字是const
++it->second;//正确

2.set的迭代器都是const类型
3.通常不对关联容器使用泛型算法。

• 对于修改或重排容器元素的算法，set元素是const，map的key是const，所以不能用
• 对于只读元素算法，需要搜索序列，一般不用。它自己会定义比如find成员，这种专用的find会比泛型快得多。
• 如果要对一个关联容器使用泛型算法，要么将它当中源序列，要么当中目的位置。比如copy，

//11.3.1
void Chapter11In2To3()
{
    pair<string,int> pair1;
    vector<pair<string,int>> xulie;
    string str;
    int no;
    while(cin>>str)
    {
        cin>>no;
        pair<string,int> pair (str,no);
        pair1=make_pair(str,no);
        pair1.first=str;
        pair1.second=no;
        xulie.push_back(pair1);
    }
}
//11.3.1
void Chapter11In3To1()
{
    //mapped_type代表每个关键字对应的类型test(vector),key_type代表此容器类型的关键字类型test(int),value_type代表pair<const key_type,mapped_type>
    //map<int,vector<int>> test;
    //auto map_it=test.cbegin();//cbegin()返回值是const类型，只读迭代器，不可以修改
    //while(map_it!=test.cend())
    //{

    //}

    multiset<string> c;
    vector<string> v;
    copy(c.begin(),c.end(),inserter(v,v.end()));
}

13.3.2 添加元素

1.set插入操作：会去重复元素
2.map插入操作：以pair的形式插入

word_count.insert({word,1});
word_count.insert(make_pair(word,1));
word_count.insert(pair<string,int>(word,1));

3.insert的返回值为pair，first成员为插入位置迭代器，second为bool，表示是否插入成功

while(cin>>word)
{
    auto ret=word_count.insert({word,1});
    if(!ret.second)
        ++ret.first->second;
}

13.3.3删除元素

1.关联容器自带的erase
接受一个key_type参数，返回实际删除的数量；
对允许重复关键字的容器，删除元素的数量可能大于1；

13.3.4map的下标操作

1.使用下标赋值，如果没有这个关键字则会添加并初始化。为了防止这种情况，可以使用c.at(k),不存在元素会抛出异常

13.3.5访问元素

1.map使用find代替下标

if(word_count.find("foobar")==word_count.end())

2.在multi中查找元素

string search_item("Alain");
auto entries=authors.count(search_item);
auto iter=authors.find(search_item);
while(entries)
{
    cout<<iter->second<<endl;
    ++iter;
    --entries;
}

3.使用lower_bound和upper_bound来解决上述问题

for(auto beg=authors.lower_bound(search_item),end=authors.upper_bound(search_item);beg!=end;++beg)
{
    cout<<beg->second;
}

4.equal_range函数
返回pair，first为第一个和关键字匹配的元素，second为最后一个与关键字匹配的元素

for(auto pos=authors.equal_range(search_item);pos.first!=pos.second;++pos.first)
{}

13.3.6 一个转换单词的map

void Chapter11In3To6()
{
    ifstream in("test.txt");
    if(!in.is_open())
    {
        cout<<"open error"<<endl;
        exit(1);
    }
    map<string,string> mapt;
    char line[20];
    string linestr;
    string key;
    string value;
    while(!in.eof())
    {
        in.getline(line,20);
        linestr=line;
        key=linestr.substr(0,linestr.find(" "));
        value=linestr.substr(linestr.find(" ")+1,linestr.length()-linestr.find(" ")+1);
        mapt[key]=value;
    }
    cout<<"请输入一段简写字符串"<<endl;
    string str;
    while(cin>>str)
    {
        auto map_it=mapt.find(str);
        if(map_it!=mapt.end())
            cout<<map_it->second<<'\t';
        else
            cout<<str<<'\t';
    }
}

11.4 无序容器

1.使用哈希函数和关键字类型的==运算符组织
2.无序容器提供了与有序容器相同的操作，可以用一个无序容器替换对于的有序容器，反之亦然；
3.管理桶

• 桶接口
• 桶迭代
• 哈希策略

4.无序容器对关键字类型的要求