STL学习笔记— —容器map和multimap

简介

在头文件<map> 中定义

namespace std 
{
    template <typename Key, typename T,
            typename Compare = less<Key>,
            typename Allocator = allocator<pair<const Key,T> > >
        class map;
    template <typename Key, typename T,
            typename Compare = less<Key>,
            typename Allocator = allocator<pair<const Key,T> > >
        class multimap;
}

map和multimap都是有序关联容器，包含具有唯一键的键值对。键使用比较函数Compare比较来进行排序。搜索，删除和插入操作具有对数复杂性。map和multimap通常实现为红黑树。multimap相对map来说能够允许重复值的存在。

map和multimap操作

构造、复制与析构

map c //默认构造函数；创建一个空map/multimap

map c(op) //创建一个空map/multimap，并以op原则作为排序准则

map c(c2) //复制构造函数；创建一个新的map/multimap作为c2的副本（所有元素都被复制）

map c = c2 //复制构造函数；创建一个新的map作为c2的副本（所有元素都被复制）

map c(rv) //移动构造函数；使用右值对象rv创建一个新map/multimap

map c = rv //移动构造函数；使用右值对象rv创建一个新map/multimap

map c(beg,end) //创建一个map/multimap，并使用beg到end范围内的值进行初始化

map c(beg,end,op) //创建一个map/multimap，并使用beg到end范围内以op原则排序后的值进行初始化

map c(initlist) //创建一个map/multimap，并使用初始化列表进行初始化

map c = initlist //创建一个map/multimap，并使用初始化列表进行初始化

c.~map() //销毁所有元素并释放内存

在这里map可能是如下的一种：

map<Key,Val> //以less<>为排序准则的map

map<Key,Val,Op> //以op为排序准则的map

multimap<Key,Val> //以less<>为排序准则的multimap

multimap<Key,Val,Op> //以op为排序准则的multimap

非变动性操作

c.key_comp() //返回比较准则

c.value_comp() //返回对值比较的标准 (与
key_comp()相同)

c.empty() //判断容器是否为空，与size()==0相同，但可能更快

c.size() //返回当前元素数量

c.max_size() //返回可容纳的元素最大数量

c1 == c2 //判断c1与c2是否相等

c1 != c2 //判断c1与c2是否不相等，等同于!(c1==c2)

c1 < c2 //判断c1是否小于c2

c1 > c2 //判断c1是否大于c2

c1 <= c2 //判断c1是否小于等于c2

c1 >= c2 //判断c1是否大于等于c2

特殊查询操作

c.count(key) //返回键值为key的元素个数

c.find(key) //返回第一个键值为key的位置，若没找到返回end()

c.lower_bound(key) //返回键值为key的第一个可插入的位置，也就是键值 >= key的第一个元素位置

c.upper_bound(key) //返回键值为key的最后一个可插入的位置，也就是键值 > key的第一个元素位置

c.equal_range(key) //返回键值为key的可插入的第一个位置和最后一个位置的区间，也就是键值 == key的元素区间

赋值

c = c2 //将c2所有元素赋值给c

c = rv //将右值对象rv的所有元素移动赋值给c

c = initlist //使用初始化列表进行赋值

c1.swap(c2) //交换c1和c2的数

swap(c1,c2) //交换c1和c2的数

迭代器相关函数

c.begin() //返回一个双向迭代器，指向第一个元素

c.end() //返回一个双向迭代器，指向最后一个元素

c.cbegin() //返回一个双向常迭代器，指向第一个元素

c.cend() //返回一个双向常迭代器，指向最后一个元素

c.rbegin() //返回一个逆向迭代器，指向逆向迭代的第一个元素

c.rend() //返回一个逆向迭代器，指向逆向迭代的最后一个元素

c.crbegin() //返回一个逆向常迭代器，指向逆向迭代的第一个元素

c.crend() //返回一个逆向常迭代器，指向逆向迭代的最后一个元素

插入和移除元素

c.insert(val) //插入一个val的副本，返回新元素位置（对map来说不论成功与否）

c.insert(pos,val) //插入一个val副本，返回新元素位置（pos应该是插入的搜寻起点）

c.insert(beg,end) //将范围beg到end的所有元素的副本插入到c（无返回值）

c.insert(initlist) //插入初始化列表的所有元素的副本（无返回值）

c.emplace(args...) //插入一个使用args初始化的元素副本，返回新元素位置（对map来说不论成功与否）

c.emplace_hint(pos,args...) //插入一个使用args初始化的元素副本，返回新元素位置（pos应该是插入的搜寻起点）

c.erase(val) //移除所有与val值相等的元素，并返移除的元素个数

c.erase(pos) //移除迭代器位置的元素，并返回下个元素的位置

c.erase(beg,end) //移除beg到end范围内的所有元素，并返回下个元素的位置

c.clear() //移除所以元素，清空容器

键值对转递

//使用value_type
std::map<std::string,float> coll;

coll.insert(std::map<std::string,float>::value_type("otto",22.3));

//使用pair<>
std::map<std::string,float> coll;

coll.insert(std::pair<std::string,float>("otto",22.3));

//使用make_pair()
std::map<std::string,float> coll;

coll.insert(std::make_pair("otto",22.3));

把map当作关联数组使用

c[key] //返回一个指向键值为key的元素的引用，如果不存在就插入这个元素

c.at(key) //返回一个指向键值为key的元素的引用

栗子1

//使用算法和lambda

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

using namespace std;

int main()
{
    map<string,double> coll { { "tim", 9.9 }, { "struppi", 11.77 } };

    //对每个元素的值平方
    for_each (coll.begin(), coll.end(),
              [] (pair<const string,double>& elem)
              {
                  elem.second *= elem.second;
                });

    //输出元素
    for_each (coll.begin(), coll.end(),
              [] (const map<string,double>::value_type& elem)
              {
                  cout << elem.first << ": " << elem.second << endl;
                });

    return 0;
}

输出1

struppi: 138.533
tim: 98.01

栗子2

//当作关联数组使用

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

using namespace std;

int main()
{
    //创建map，键为string，值为float
    typedef map<string,float> StringFloatMap;
    StringFloatMap stocks;

    //插入元素
    stocks["BASF"] = 369.50;
    stocks["VW"] = 413.50;
    stocks["Daimler"] = 819.00;
    stocks["BMW"] = 834.00;
    stocks["Siemens"] = 842.20;

    //输出元素
    StringFloatMap::iterator pos;
    cout << left; //左对齐
    for (pos = stocks.begin(); pos != stocks.end(); ++pos)
    {
        cout << "stock: " << setw(12) << pos->first
             << "price: " << pos->second << endl;
    }
    cout << endl;

    //所有price翻一番
    for (pos = stocks.begin(); pos != stocks.end(); ++pos)
    {
        pos->second *= 2;
    }

    //输出元素
    for (pos = stocks.begin(); pos != stocks.end(); ++pos)
    {
        cout << "stock: " << setw(12) << pos->first
             << "price: " << pos->second << endl;
    }
    cout << endl;

    // 修改VM键为Volkswagen键
    stocks["Volkswagen"] = stocks["VW"];
    stocks.erase("VW");

    //输出元素
    for (pos = stocks.begin(); pos != stocks.end(); ++pos)
    {
        cout << "stock: " << setw(12) << pos->first
             << "price: " << pos->second << endl;
    }

    return 0;
}

输出2

stock: BASF price: 369.5
stock: BMW price: 834
stock: Daimler price: 819
stock: Siemens price: 842.2
stock: VW price: 413.5

stock: BASF price: 739
stock: BMW price: 1668
stock: Daimler price: 1638
stock: Siemens price: 1684.4
stock: VW price: 827

stock: BASF price: 739
stock: BMW price: 1668
stock: Daimler price: 1638
stock: Siemens price: 1684.4
stock: Volkswagen price: 827

栗子3

//作为字典使用

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

using namespace std;

int main()
{
    //创建multimap作为字典
    multimap<string,string> dict;

    //插入元素
    dict.insert ( { {"day","Tag"}, {"strange","fremd"},
        {"car","Auto"}, {"smart","elegant"},
        {"trait","Merkmal"}, {"strange","seltsam"},
        {"smart","raffiniert"}, {"smart","klug"},
        {"clever","raffiniert"}
        } );

    //输出元素
    cout.setf (ios::left, ios::adjustfield);
    cout << ' ' << setw(10) << "english "
         << "german " << endl;
    cout << setfill('-') << setw(20) << ""
         << setfill(' ') << endl;
    for ( const auto& elem : dict )
    {
        cout << ' ' << setw(10) << elem.first
             << elem.second << endl;
    }
    cout << endl;

    //输出所有smart键的值
    string word("smart");
    cout << word << ": " << endl;
    for (auto pos = dict.lower_bound(word);
            pos != dict.upper_bound(word);
            ++pos)
    {
        cout << " " << pos->second << endl;
    }

    //输出所以值为raffiniert的键
    word = ("raffiniert");
    cout << word << ": " << endl;
    for (const auto& elem : dict)
    {
        if (elem.second == word)
        {
            cout << " " << elem.first << endl;
        }
    }

    return 0;
}

输出3

english german
--------------------
car Auto
clever raffiniert
day Tag
smart elegant
smart raffiniert
smart klug
strange fremd
strange seltsam
trait Merkmal

smart:
elegant
raffiniert
klug
raffiniert:
clever
smart

栗子4

//查找

#include <map>
#include <iostream>
#include <algorithm>
#include <utility>
using namespace std;
int main()
{
    // 创建键与值都为float的map，并初始化
    map<float,float> coll = { {1,7}, {2,4}, {3,2}, {4,3},
        {5,6}, {6,1}, {7,3}
    };

    //查询一个key为3的元素，对数时间复杂度
    auto posKey = coll.find(3.0);
    if (posKey != coll.end())
    {
        cout << "key 3.0 found ("
             << posKey->first << ":"
             << posKey->second << ")" << endl;
    }

    //查询一个值为3的元素，线性时间复杂度
    auto posVal = find_if(coll.begin(),coll.end(),
                          [] (const pair<float,float>& elem)
    {
        return elem.second == 3.0;
    });

    if (posVal != coll.end())
    {
        cout << "value 3.0 found ("
             << posVal->first << ":"
             << posVal->second << ")" << endl;
    }

    return 0;
}

输出4

key 3.0 found (3:2)
value 3.0 found (4:3)

栗子5

//结合string，运行时排序

#include <iostream>
#include <iomanip>
#include <map>
#include <string>
#include <algorithm>
#include <cctype>

using namespace std;

//字符串比较函数，允许在运行事设置比较准则，允许在不分大小写的情况下比较
class RuntimeStringCmp
{
public:

    //比较标准常数
    enum cmp_mode {normal, nocase};
private:

    //实际比较模式
    const cmp_mode mode;

    //辅助函数，大小转化一致
    static bool nocase_compare (char c1, char c2)
    {
        return toupper(c1) < toupper(c2);
    }
public:

    //构造函数: 初始化比较准则
    RuntimeStringCmp (cmp_mode m=normal) : mode(m)
    {
    }

    //比较
    bool operator() (const string& s1, const string& s2) const
    {
        if (mode == normal)
        {
            return s1<s2;
        }
        else
        {
            return lexicographical_compare (s1.begin(), s1.end(),
                                            s2.begin(), s2.end(),
                                            nocase_compare);
        }
    }
};

typedef map<string,string,RuntimeStringCmp> StringStringMap;

//填充和输出函数
void fillAndPrint(StringStringMap& coll);

int main()
{
    //以默认比较准则创建容器
    StringStringMap coll1;
    fillAndPrint(coll1);

    //创建一个不区分大小写的比较对象
    RuntimeStringCmp ignorecase(RuntimeStringCmp::nocase);

    //创建一个不区分大小写的比较准则容器
    StringStringMap coll2(ignorecase);
    fillAndPrint(coll2);

    return 0;
}
void fillAndPrint(StringStringMap& coll)
{
    //插入元素
    coll["Deutschland"] = "Germany";
    coll["deutsch"] = "German";
    coll["Haken"] = "snag";
    coll["arbeiten"] = "work";
    coll["Hund"] = "dog";
    coll["gehen"] = "go";
    coll["Unternehmen"] = "enterprise";
    coll["unternehmen"] = "undertake";
    coll["gehen"] = "walk";
    coll["Bestatter"] = "undertaker";

    //输出元素
    cout.setf(ios::left, ios::adjustfield);
    for (const auto& elem : coll)
    {
        cout << setw(15) << elem.first << " "
             << elem.second << endl;
    }
    cout << endl;
}

输出5

Bestatter undertaker
Deutschland Germany
Haken snag
Hund dog
Unternehmen enterprise
arbeiten work
deutsch German
gehen walk
unternehmen undertake

arbeiten work
Bestatter undertaker
deutsch German
Deutschland Germany
gehen walk
Haken snag
Hund dog
Unternehmen undertake