【足迹C++primer】38、关联容器操作(1)

关联容器操作

关联容器中还定义了三个类型,如下:

    set<string>::value_type v1;     //这个v1是string类型
    set<string>::key_type v2;       //这个v2是string类型
    map<string, int>::value_type v3;    //v3是pair类型pair<const string, int>
    map<string, int>::key_type v4;      //v4是string类型
    map<string, int>::mapped_type v5;   //v5是int类型

关联容器迭代器

对map而言,value_type是一个pair类型的!!!

我已经感受到了这章有点多,所以分成两部分了- -

    map<string, size_t> word_count; // empty map from string to size_t
    string word;
    while (cin >> word)
      ++word_count[word];

    //获得指向word_count中的一个元素的迭代器
    auto map_it=word_count.begin();
    //*map_it是指向一个pair<const string, size_t>对象的引用
    cout<<map_it->first;        //打印此元素的关键字
    cout<<" "<<map_it->second;  //打印此元素的值
//    map_it->first="new key";    //错误:关键字是const的
    ++map_it->second;           //正确:我们可以通过迭代器改变元素

set的迭代器是const的

这就是说,这个set的值是没法更改的!

//可以用一个set迭代器来读取元素的值,但不能修改
void fun3()
{
    set<int> iset={0,1,2,3,4,5,6,7,8,9};
    set<int>::iterator set_it=iset.begin();
    if(set_it != iset.end())
    {
//        *set_it=42;     //错误!!!
        cout<<*set_it<<endl;    //正确:可以读关键字
    }
}

遍历关联容器

//遍历关联容器
void fun4()
{
    map<string, size_t> word_count; // empty map from string to size_t
    string word;
    while (cin >> word)
      ++word_count[word];

    //获得指向word_count中的一个元素的迭代器
    auto map_it=word_count.cbegin();
    //比较当前迭代器和尾后迭代器
    while(map_it != word_count.cend())
    {
        //解引用迭代器,打印关键字-值对
        cout<<map_it->first<<" occurs "
            <<map_it->second<<" times "<<endl;

        ++map_it;   //递增迭代器,移动到下一个元素
    }
}

添加元素

    vector<int> ivec={2,4,6,8,2,4,6,8};     //ivec有8个元素
    set<int> set2;          //空集合
    set2.insert(ivec.cbegin(), ivec.cend());    //set2有4个元素
    set2.insert({1,3,5,7,1,3,5,7});         //现在set2有8个元素

关联容器的insert成员向容器中添加一个元素或一个元素范围。

好蛋疼啊!!!这都放假了,我还在敲代码。

//向map添加元素
void fun6()
{
    map<string, size_t> word_count; // empty map from string to size_t
    string word;
    while (cin >> word)
      ++word_count[word];

    //向word_count插入word的4种方法
    word_count.insert({word, 1});
    word_count.insert(make_pair(word, 1));
    word_count.insert(pair<string, size_t>(word, 1));
    word_count.insert(map<string, size_t>::value_type(word, 1));
}

检测insert的返回值

pair的first成员是一个迭代器,指向具有给定关键字的元素;second成员是一个bool值,指出元素是插入成功还是已经存放在于容器中。

现在的感觉可就是我要速度吧这本书搞完!!!!

//检查insert的返回值
//重写单词计数程序
void fun7()
{
    map<string, size_t> word_count; //从string到size_t的空map
    string word;
    while(cin>>word)
    {
        //插入一个元素,关键字等于word,值为1
        //若word已在word_count中,insert什么也不做
        auto ret=word_count.insert({word, 1});
        if(!ret.second)
        {
            ++ret.first->second;    //递增计数器
        }
    }
}

向multimap和multiset添加元素,这个可以重复

这就一句话,看标题,如果不懂什么叫multimap和multiset点击超链接

//向multimap和multiset添加元素,这个可以重复
void fun8()
{
    multimap<string, string> authors;
    //插入第一个元素,关键字为Barth, John
    authors.insert({"Barth, John", "Sot-Weed Factor"});
    //正确:添加第二个元素,关键字也是Barth, John
    authors.insert({"Barth, John", "Lost in the Funhouse"});
}

删除元素

关联容器定义了三个版本的erase

c.erase(k)
把k给我删除了,返回一个size_type值,指出删除的元素的数量

c.erase(p)
吧p指向的元素删掉,p是一个迭代器p不能指向c.end()

c.erase(b, e)
删除迭代器对b和e所表示的范围中的元素。返回e

//删除元素
void fun9()
{
    map<string, size_t> word_count; // empty map from string to size_t
    string word,removal_word;
    while (cin >> word)
      ++word_count[word];

    //删除一个关键字,返回删除的元素数量
    cin>>removal_word;
    if(word_count.erase(removal_word))
        cout<<" ok: "<<removal_word<<" remove\n";
    else
        cout<<" oops: "<<removal_word<<" not found!\n";
}

完整全部代码:

/**
* 功能:关联容器操作
* 时间:2014年6月26日16:40:51
* 作者:cutter_point
*/

#include<iostream>
#include<set>
#include<map>
#include<vector>
#include<string>

using namespace std;

//关联容器额外的类型别名
void fun1()
{
    set<string>::value_type v1;     //这个v1是string类型
    set<string>::key_type v2;       //这个v2是string类型
    map<string, int>::value_type v3;    //v3是pair类型pair<const string, int>
    map<string, int>::key_type v4;      //v4是string类型
    map<string, int>::mapped_type v5;   //v5是int类型
}

//关联容器迭代器
void fun2()
{
    map<string, size_t> word_count; // empty map from string to size_t
    string word;
    while (cin >> word)
      ++word_count[word];

    //获得指向word_count中的一个元素的迭代器
    auto map_it=word_count.begin();
    //*map_it是指向一个pair<const string, size_t>对象的引用
    cout<<map_it->first;        //打印此元素的关键字
    cout<<" "<<map_it->second;  //打印此元素的值
//    map_it->first="new key";    //错误:关键字是const的
    ++map_it->second;           //正确:我们可以通过迭代器改变元素
}

//可以用一个set迭代器来读取元素的值,但不能修改
void fun3()
{
    set<int> iset={0,1,2,3,4,5,6,7,8,9};
    set<int>::iterator set_it=iset.begin();
    if(set_it != iset.end())
    {
//        *set_it=42;     //错误!!!
        cout<<*set_it<<endl;    //正确:可以读关键字
    }
}

//遍历关联容器
void fun4()
{
    map<string, size_t> word_count; // empty map from string to size_t
    string word;
    while (cin >> word)
      ++word_count[word];

    //获得指向word_count中的一个元素的迭代器
    auto map_it=word_count.cbegin();
    //比较当前迭代器和尾后迭代器
    while(map_it != word_count.cend())
    {
        //解引用迭代器,打印关键字-值对
        cout<<map_it->first<<" occurs "
            <<map_it->second<<" times "<<endl;

        ++map_it;   //递增迭代器,移动到下一个元素
    }
}

//添加元素
void fun5()
{
    vector<int> ivec={2,4,6,8,2,4,6,8};     //ivec有8个元素
    set<int> set2;          //空集合
    set2.insert(ivec.cbegin(), ivec.cend());    //set2有4个元素
    set2.insert({1,3,5,7,1,3,5,7});         //现在set2有8个元素
}

//向map添加元素
void fun6()
{
    map<string, size_t> word_count; // empty map from string to size_t
    string word;
    while (cin >> word)
      ++word_count[word];

    //向word_count插入word的4种方法
    word_count.insert({word, 1});
    word_count.insert(make_pair(word, 1));
    word_count.insert(pair<string, size_t>(word, 1));
    word_count.insert(map<string, size_t>::value_type(word, 1));
}

//检查insert的返回值
//重写单词计数程序
void fun7()
{
    map<string, size_t> word_count; //从string到size_t的空map
    string word;
    while(cin>>word)
    {
        //插入一个元素,关键字等于word,值为1
        //若word已在word_count中,insert什么也不做
        auto ret=word_count.insert({word, 1});
        if(!ret.second)
        {
            ++ret.first->second;    //递增计数器
        }
    }
}

//向multimap和multiset添加元素,这个可以重复
void fun8()
{
    multimap<string, string> authors;
    //插入第一个元素,关键字为Barth, John
    authors.insert({"Barth, John", "Sot-Weed Factor"});
    //正确:添加第二个元素,关键字也是Barth, John
    authors.insert({"Barth, John", "Lost in the Funhouse"});
}

//删除元素
void fun9()
{
    map<string, size_t> word_count; // empty map from string to size_t
    string word,removal_word;
    while (cin >> word)
      ++word_count[word];

    //删除一个关键字,返回删除的元素数量
    cin>>removal_word;
    if(word_count.erase(removal_word))
        cout<<" ok: "<<removal_word<<" remove\n";
    else
        cout<<" oops: "<<removal_word<<" not found!\n";
}

int main()
{
    fun1();
    fun2();
    fun3();
    fun4();
    fun5();
    fun6();
    fun7();
    fun8();
    fun9();
    return 0;
}

PS:最后可能要说的就是,放假的这段时间微博可能会停更了,应为暑假有事情要做,而且不像在学校那么闲,估计会停更2个月,但是学习我是不会停的,哈哈,到时微博更新的时候没准已经不是C++primer的内容了,大家也要加油啊!!!!到时候可不要被我超出去了哦

【足迹C++primer】38、关联容器操作(1)

时间: 2024-10-03 22:40:43

【足迹C++primer】38、关联容器操作(1)的相关文章

【足迹C++primer】38、关联容器操作(2)

关联容器操作(2) map的下标操作 map的下标操作 map和unordered_map容器提供了下标运算符合一个对应的at函数 对于一个map使用下标操作,其行为与数组或vector上的下标操作很不相同: 使用一个不再容器中的关键字作为下标,会添加一个此关键字的元素到map中 map和unordered_map的下标操作 c[k] 返回关键字为k的元素,如果关键字k不再c中,添加一个关键字为k的元素,对其进行值初始化 c.at(k) 访问关键字为k的元素,带参数检测,如果k不再c重那么返回一

c++ primer 10 关联容器

关联容器和顺序容器的本质差别在于:关联容器通过键(key)存储和读取元素,顺序容器则通过元素在容器中的位置顺序存储和访问元素 关联容器类型 map 关联数组:元素通过键来存储和读取 set 大小可变的集合,支持通过键实现的快速读取 multimap 支持同一个键多次出现的 map 类型 multiset 支持同一个键多次出现的 set 类型 pair类型 pair是一种模版类型,在创建pair对象,必须提供两个类型名. 头文件 utility pairs 类型提供的操作 pair<T1, T2>

《C++primer(第五版)》学习之路-第十一章:关联容器

[ 声明:版权所有,转载请标明出处,请勿用于商业用途.  联系信箱:[email protected]] 11.1 使用关联容器 1. 关联容器类型 按关键字有序保存元素 map                    关联数组,保存关键字-值对 set                      关键字即值,即只保存关键字的容器 multimap            关键字可重复出现的map multiset              关键字可重复出现的set 无序集合 unordered_ma

C++ Primer笔记7_STL之关联容器

关联容器 与顺序容器不同,关联容器的元素是按关键字来访问和保存的.而顺序容器中的元素是按他们在容器中的位置来顺序保存的. 关联容器最常见的是map.set.multimap.multiset map的元素以键-值[key-value]对的形式组织:键用作元素在map中的索引,而值则表示所存储和读取的数据. set仅包含一个键,并有效的支持关于某个键是否存在的查询. pair类型 首先介绍下pair,pair定义在utility头文件中,一个pair保存两个数据成员,类似容器,pair是一个用来生

CH11 关联容器

关联容器与顺序容器有着根本的不同:关联容器中的元素是按关键字来保存和访问的,而顺序容器是按它们在容器中的位置来顺序保存和访问的.两个主要的关联容器:map和set map 中的元素的是一个key-value对:关键字是用来索引值关联的数据.set:每个关键字值包含一个关键字. 关联容器类型: map 保存key-value  map<key,value> set 保存关键字key set<key> multimap 关键字可以重复出现的map multiset 关键字可以重复出现的

关联容器——map、set

map类型通常被称为关联数组,与正常数组类似,不同之处在于其下标不必是整数.我们通过一个关键字而不是位置来查找值(键值对). 与之相对,set就是关键字的简单集合.当只是想知道一个值是否存在时,set是最有用的. 类似顺序容器,关联容器也是模板,为了定义一个map,我们必须指定关键字和值得类型.例:map<string,int>test;一个test的空map,关键字是string.值是int的.set<string> e={"hello"};设置关键字集合,类

关联容器详解(一)

本文为对<C++ primer (中文版第五版)>中有关关联容器的讲解和网上大神们的博客整理而成. 关联容器和顺序容器的根本不同在于:关联容器中的元素是按关键字来保存和访问的,而顺序容器中的元素则是按它们在容器中的位置来顺序保存和访问的.顺序容器有vector.deque.list.forward_list.array.string等,更多详情,可见melonstreet的博客. 关联容器支持高效的关键字查找和访问.主要的关联容器类型是map和set,其中map中的元素是一些关键字-值(key

第11章 关联容器

map,管理数组,存储“关键字-值” set,简单集合,存储“关键字” 四个关联容器的头文件map.set.unordered_map.unordered_set 关联容器有8种,特点如下: 每个容器都是set或者map 分为允许关键字重复(multi)和不允许关键字重复 顺序保存和无序保存(unordered,哈希函数组织的结构) unordered_multiset是一个允许关键字重复,元素无序保存的集合 set是一个要求关键字不重复,元素有序保存的集合 map<string, size_t

STL2——关联容器

关联容器 关联容器支持通过键(key)来高效地查找和读取元素.两个基本的关联容器是map和set,map的元素以键-值对形式组织,键用做索引,值表示存储和读取的数据,set包含一个键,并有效地支持关于某个键是否存在的查询. 引言:pair类型 #include<utility> pair<int,int>p; p.first=5; p.second=6; pair<int,int>p2; p2=make_pair(5,7); pair<int,int>p3(