map的基本操作和使用

以你之姓@ 2022-06-07 00:09 229阅读 0赞

*  map 是一种关联容器, 将键值和映射值组合成元素并且按照特定顺序进行排列, 通常键值用来排  
    序和唯一标识元素, 映射值用来存储和键值相关的内容;
 *  键值类型和映射值类型不要求一样, 但是通常声明为typedef pair

#include<iostream>
    #include <map>
    #include <string>
    
    using namespace std;
    
    template <class Key,
              class T,
              class Compare = less<Key>,
              class Alloc = allocator<pair<const, Key, T>>
              > class map;
    
    bool fncomp(char lns, char rns)
    {
        return lns < rns;
    }
    
    struct clascomp
    {
        bool operator()(const char& lns, const char& rns)const
        {
            return lns < rns;
    
        }
    };
    
    
    int main()
    {
        //constructors 的几种构建方式:
        map<char, int> first;
        first['a'] = 10;
        first['b'] = 20;
        first['c'] = 30;
        first['d'] = 40;
    
        map<char, int> second(first.begin(), first.end());
        map<char, int> third(second);
        map<char, int, clascomp> fourth;
    
        bool(*fn_pt)(char, char) = fncomp;
        map<char, int, bool(*)(char, char)> fifth(fn_pt);
    
        //.at()用于返回对键k标识元素的映射值的引用,如果K在容器map里面不存在任何映射值,使
        //用out_of_range抛出异常;相关函数的声明包括:mapped_type& at(const key_type& k);
        //const mapped_type& at(const key_type& k)const;
    
        map<string, int> mymap =
        {
            {
       "alpah", 0},
            {
       "beta", 0},
            {
       "gamma", 0}
        };
        mymap.at("alpah") = 10;
        mymap.at("beta") = 20;
        mymap.at("gamma") = 30;
    
        cout << "mymap contains: ";
        for (auto X : mymap)
            cout << "(" << X.first << "," << X.second << ")" << " ";
        cout << endl;
    
        //.begin(),.end()用于访问里面元素的迭代器
    
        cout << "mymap contains: ";
        for (map<string, int>::iterator It = mymap.begin(); It != mymap.end(); ++It)
            cout << "(" << It->first + "lixun" << " => " << It->second + 10 << ")" << " ";
        cout << endl;
    
        //.cbegin().cend() 表示不允许进行修改成员的值
        cout << "mymap contains const: ";
        for (auto It = mymap.cbegin(); It != mymap.cend(); ++It)
            cout << "(" << It->first  << " => " << It->second << ")" << " ";
        cout << endl;
    
        //.rbegin()以及.rend()是用来进行反向遍历的迭代器;
    
        cout << "mymap contains reverse: ";
        for (auto It = mymap.rbegin(); It != mymap.rend(); ++It)
            cout << "(" << It->first + "lixun" << " => " << It->second + 10 << ")" << " ";
        cout << endl;
        //.rcbegin()以及.rcend()是用来进行反向遍历的迭代器;
    
        cout << "mymap contains reverse: ";
        for (auto It = mymap.crbegin(); It != mymap.crend(); ++It)
            cout << "(" << It->first << " => " << It->second << ")" << " ";
        cout << endl;
    
        //.clear()用于清空里面的元素,函数声明是:void clear() noexcept;
    
        //.cout()在map里面查找一个和K相等的值,并且返回相等值的数量;
    
        map<char, int> mymap1;
        mymap1['a'] = 10;
        mymap1['b'] = 9;
        mymap1['c'] = 8;
    
        char c;
        for ( c = 'a'; c < 'g'; ++c)
        {
            cout << c << " ";
            if (mymap1.count(c) > 0)
                cout << "is an elememt of mymap1;" << endl;
            else
                cout << "is not an element of mymap1;" << endl;
        }
    
        //.emplace():template<class... Args) pair<iteraotr,bool> emplace(Arg&&...args);
        //如果插入的值是不唯一的,那么就插入一个新的元素,参数的类型和pair的类型是一致的;
        //如果插入成功,那么size就会增长,map里面的元素是按照对象指定的标准进行排序
        //如果元素成功插入,那么就会返回一对迭代器插入元素后的新的位置;
        //如果插入失败,那么就返回在map里面找到的和新插入元素相等的值的位置;
    
        map<char, int> mymap2;
        mymap2.emplace('x', 1);
        mymap2.emplace('y', 2);
        mymap2.emplace('z', 3);
        mymap2.emplace('k', 4);
    
        cout << "mymap2 contains: ";
        for (auto &X : mymap2)
            cout << "(" << X.first << ":" << X.second << ")" << " ";
        cout << endl;
    
        //.emplace_hint():再进行元素插入时可以指定一个位置进行元素的插入,对于元素插入的要求和
        //.emplace()是一样的;
    
        {
            auto It = mymap2.end();
            It = mymap2.emplace_hint(It, 'b', 11);
            mymap2.emplace_hint(It, 'c', 12);
            It = mymap2.begin();
            mymap2.emplace_hint(It, '3', 19);
            cout << "mymap2.emplace_hint contains: ";
            for (auto X : mymap2)
                cout << "(" << X.first << ":" << X.second << ")" << " ";
            cout << endl;
        }
    
        //.empty()用于判断是否为空操作:bool empty()const noexcept;
    
    
        //.equal_range() pair<const_iterator,const_iterator> equal_range(const key_type& k)const;
        //pair<iterator,iterator> equal_range(const key_type& k);这些函数的作用是用来返回等价于
        //元素K的范围的一个边界;因为map的特性,所以返回的元素只有一个,范围也只有一个;如果没有匹配
        //到元素,那么就返回两个都指向第一个元素的迭代器,并且返回长度是0;
        {
            auto ret = mymap2.equal_range('b');
            cout << "lower bound points to: ";
            cout << ret.first->first << "=>" << ret.first->second << " ";
            cout << endl;
            cout << "upper bound points to: ";
            cout << ret.second->first << "=>" << ret.second->second << " ";
            cout << endl;
        }
        //.erase(): iterator erase(const_iterator position);
        //size_type erase(const key_type& k);
        //iterator erase(const_iterator first,const_iterator last);
        //用于删除单个或者是某个范围里面的元素;
        {
            cout << "mymap2.erase() contains: ";
            auto It = mymap2.find('b');
            mymap2.erase(It);
            mymap2.erase('x');
            It = mymap2.find('k');
            mymap2.erase(It,mymap2.end());
            for(auto It=mymap2.begin();It!=mymap2.end();++It)
                cout << It->first << "=>" << It->second << " ";
            cout << endl;
        }
    
        //.find()用于查找某一个元素的位置,一共有两个版本:iterator find(const key_type& k);
        //const_iterator find(const key_type& k)const;
        //查找某一个元素的值,如果找不到,就返回最后一个元素的位置;
        {
            mymap2['s']=12;
            mymap2['v']=11;
            mymap2['l']=10;
            mymap2['j']=9;
            mymap2['t']=0;
    
            auto It = mymap2.find('j');
            if(It!=mymap2.end())
                mymap2.erase(It);
            cout << "mymap2.erase() contains: ";
            cout << "s=>" << mymap2.find('s')->second << " ";
            cout << "l=>" << mymap2.find('l')->second << " ";
            cout << "j=>" << mymap2.find('j')->second << " ";
            cout << "t=>" << mymap2.find('t')->second << endl;
        }
    
        //.get_allocator()函数声明是:allocator_type get_allocator()const noexcept;
        //用于返回和map关联对象的副本;
    
        {
            pair<const char,int> *p;
            p=mymap2.get_allocator().allocate(5);
            auto psize = sizeof(map<char,int>::value_type)*5;
            cout << "The allocated array has sizeof " << psize << " bytes" << endl;
            mymap2.get_allocator().deallocate(p,5);
        }
    
        //.insert()包含的函数声明:
        //pair<iterator,bool> insert(const value_type& val);
        //template<class P> pair(iterator,bool) insert(P&& val);
        //
        //iterator insert(const_iterator position,const value_type& val);
        //template<class P> iterator insert(const_iterator position,P&& val);
        //
        //template<class InputIterator>
        //void insert(InputIterator first,InputIterator last);
        //void insert(initializer_list<value_type> il);
        //再进行元素的插入过程中,元素键是唯一的,所以在进行元素插入时,需要进行检查,
        //如果元素重复,就不进行插入,迭代器返回现有元素,否则进行元素插入;
        //
        {
            map<char,int> mynewmap;
            mynewmap.insert(pair<char,int>('a',101));
            mynewmap.insert(pair<char,int>('b',102));
            mynewmap.insert(pair<char,int>('c',103));
            mynewmap.insert(pair<char,int>('c',104));
            mynewmap.insert(pair<char,int>('d',105));
    
            pair<map<char,int>::iterator,bool> ret;
            mynewmap.insert(pair<char,int>('b',212));
    
            if(ret.second==false){
                cout << "element 'b' has already exist " << endl;
            }else {
                cout << "elemen 'b' inseret successful " << endl;
            }
            map<char,int>::iterator it = mynewmap.begin();
            mynewmap.insert(it,pair<char,int>('b',300));
            mynewmap.insert(it,pair<char,int>('c',200));
    
            map<char,int> anothermap;
            anothermap.insert(mynewmap.begin(),mynewmap.find('c'));
    
            cout << "mynewmap contains: ";
            for(auto X:mynewmap)
                cout << X.first << " " << X.second << " ";
            cout << endl;
            for(auto X:anothermap)
                cout << X.first << " " << X.second << " ";
            cout << endl;
    
        }   
        //.key_comp()用于返回一个用于比较键值的对象的副本;
        //.key_compare key_comp()const;
        {
            map<char,int> mymap;
            map<char,int>::key_compare mycomp = mymap.key_comp();
    
            mymap['a']=100;
            mymap['b']=101;
            mymap['c']=102;
            cout << "mymap contains: ";
            char highest =mymap.rbegin()->first;
    
            map<char,int>::iterator it = mymap.begin();
            do{
                cout << it->first << "=>" << it->second << " ";
            }while(mycomp((*it++).first,highest));
            cout <<'\n';
    
        }
    
        //.lower_bound()包含有两种形式:iterator lower_bound(const key_type& k);
        //const_iterator lower_bound(const key_type& k) const;
    
        {
            map<char,int> mymap;
            map<char,int>::iterator itlow,itup;
            mymap['1']=16;
            mymap['2']=19;
            mymap['3']=20;
            mymap['4']=19;
            mymap['5']=17;
    
            itlow = mymap.lower_bound('3');
            itup = mymap.upper_bound('3');
            mymap.erase(itlow,itup);
    
            for(auto X:mymap){
                cout << X.first << "=>" << X.second << " ";
            }
            cout << endl;
    
        }
    
        //.max_size()用于返回当前容器可以存放的最大值;
        //size_type max_size() const noexcept;
        //
    
    
        //.operator=:用于实现两个不同的map对象进行赋值;
        //map& operator=(const map& x);拷贝
        //map& operator=(const map&& x);移动
        //map& operator=(initializer_list<value_type> il);初始化列表
    
        {
            map<char,int> first;
            map<char,int> second;
            first['x']=1;
            first['y']=2;
            first['z']=3;
            first['a']=4;
            first['b']=5;
    
            cout << "first contains: ";
    
            for(auto X:first)
                cout << "[" << X.first << ":" << X.second << " ";
            cout << endl;
            second = first;
    
            for(auto X:second)
                cout << "[" << X.first << ":" << X.second << " ";
            cout << endl;
    
            first = map<char,int>();
            cout << first.size() << endl;
        }
    
        //.mapped_type& operator[](const key_type& k);
        //mapped_type& operator[](const key_type&& k);
    
    
        //.swap()用于快速的交换两个map结构
    
        mymap1.swap(mymap1);
    
        cout << "mymap1 contains: ";
        for(auto X:mymap1)
            cout << "[" << X.first << ":" << X.second << "] ";
        cout << endl;
        cout << "mymap2 contains: ";
        for(auto X:mymap2)
            cout << "[" << X.first << ":" << X.second << "] ";
        cout << endl;
    
    
        //.upper_bound() 
        //iterator upper_bound(const key_type& k);
        //const_iterator upper_bound(const key_type& k)const;
    
    
        //.value_comp():value_compare value_comp() const;
    
        {
            map<char,int> mymap;
            mymap['a'] = 1001;
            mymap['b'] = 1002;
            mymap['c'] = 1003;
            auto highest = *mymap.rbegin();
            auto it = mymap.begin();
            cout << "mymap value contains: ";
            do{
                cout << it->first << "=>" << it->second << " ";
            }while(mymap.value_comp()(*it++,highest));
    
        }
        return 0;
    
    }