精华内容
下载资源
问答
  • map 容器

    2020-06-02 23:18:22
    作为关联式容器的一种,map 容器存储的都是 pair 对象,也就是用 pair 类模板创建的键值对。其中,各个键值对的键和值可以是任意数据类型,包括C++基本数据类型(int、double 等)、使用结构体或类自定义的类型。 ...

    作为关联式容器的一种,map 容器存储的都是 pair 对象,也就是用 pair 类模板创建的键值对。其中,各个键值对的键和值可以是任意数据类型,包括 C++ 基本数据类型(int、double 等)、使用结构体或类自定义的类型。

    与此同时,在使用 map 容器存储多个键值对时,该容器会自动根据各键值对的键的大小,按照既定的规则进行排序。默认情况下,map 容器选用std::less<T>排序规则(其中 T 表示键的数据类型),其会根据键的大小对所有键值对做升序排序。当然,根据实际情况的需要,我们可以手动指定 map 容器的排序规则,既可以选用 STL 标准库中提供的其它排序规则(比如std::greater<T>),也可以自定义排序规则。

    另外需要注意的是,使用 map 容器存储的各个键值对,键的值既不能重复也不能被修改。换句话说,map 容器中存储的各个键值对不仅键的值独一无二,键的类型也会用 const 修饰,这意味着只要键值对被存储到 map 容器中,其键的值将不能再做任何修改。

     

    std::pair

    std::pair 是一个结构体模板,其可于一个单元内存储两个相异对象。是 std::tuple 的拥有两个元素的特殊情况。

    一般来说,pair 可以封装任意类型的对象,可以生成各种不同的 std::pair<T1, T2> 对象,可以是数组对象或者包含 std::pair<T1,T2> 的 vector 容器。pair 还可以封装两个序列容器或两个序列容器的指针。

    1. 定义

    #include <utility>
    template<class T1, class T2> struct pair;

    模板参数 T1 和 T2 是 pair 所存储的元素的类型。

    包含有两个成员变量 first 和 second,而且都是 public 修饰的,通过 "." 访问。

    其中 first 类型为T1, second 类型为T2。

    1 pair的应用

    pair是将2个数据组合成一个数据,当需要这样的需求时就可以使用pair,如stl中的map就是将key和value放在一起来保存。另一个应用是,当一个函数需要返回2个数据的时候,可以选择pair。 pair的实现是一个结构体,主要的两个成员变量是first second 因为是使用struct不是class,所以可以直接使用pair的成员变量。

    2 make_pair函数

    template pair make_pair(T1 a, T2 b) { return pair(a, b); }

    很明显,我们可以使用pair的构造函数也可以使用make_pair来生成我们需要的pair。 一般make_pair都使用在需要pair做参数的位置,可以直接调用make_pair生成pair对象很方便,代码也很清晰。 另一个使用的方面就是pair可以接受隐式的类型转换,这样可以获得更高的灵活度。灵活度也带来了一些问题如:

    std::pair<int, float>(1, 1.1);

    std::make_pair(1, 1.1);

    是不同的,第一个就是float,而第2个会自己匹配成double。

    类模板:template <class T1, class T2> struct pair

    参数:T1是第一个值的数据类型,T2是第二个值的数据类型。

    功能:pair将一对值组合成一个值,这一对值可以具有不同的数据类型(T1和T2),两个值可以分别用pair的两个公有函数first和second访问。

    具体用法:

    1.定义(构造):

    1     pair<int, double> p1;  //使用默认构造函数
    2     pair<int, double> p2(1, 2.4);  //用给定值初始化
    3     pair<int, double> p3(p2);  //拷贝构造函数
    2.访问两个元素(通过first和second):

    1     pair<int, double> p1;  //使用默认构造函数
    2     p1.first = 1;
    3     p1.second = 2.5;
    4     cout << p1.first << ' ' << p1.second << endl;
    输出结果:1 2.5
     

     

    创建C++ map容器的几种方法

    map 容器的模板类中包含多种构造函数,因此创建 map 容器的方式也有多种,下面就几种常用的创建 map 容器的方法,做一一讲解。

    1) 通过调用 map 容器类的默认构造函数,可以创建出一个空的 map 容器,比如:

    std::map<std::string, int>myMap;

    通过此方式创建出的 myMap 容器,初始状态下是空的,即没有存储任何键值对。鉴于空 map 容器可以根据需要随时添加新的键值对,因此创建空 map 容器是比较常用的。

    2) 当然在创建 map 容器的同时,也可以进行初始化,比如:

    std::map<std::string, int>myMap{ {"C语言教程",10},{"STL教程",20} };

    由此,myMap 容器在初始状态下,就包含有 2 个键值对。

    再次强调,map 容器中存储的键值对,其本质都是 pair 类模板创建的 pair 对象。因此,下面程序也可以创建出一模一样的 myMap 容器:

    std::map<std::string, int>myMap{std::make_pair("C语言教程",10),std::make_pair("STL教程",20)};

     3) 除此之外,在某些场景中,可以利用先前已创建好的 map 容器,再创建一个新的 map 容器。例如:

    std::map<std::string, int>newMap(myMap);

    由此,通过调用 map 容器的拷贝(复制)构造函数,即可成功创建一个和 myMap 完全一样的 newMap 容器。

    C++ 11 标准中,还为 map 容器增添了移动构造函数。当有临时的 map 对象作为参数,传递给要初始化的 map 容器时,此时就会调用移动构造函数。举个例子:

    #创建一个会返回临时 map 对象的函数
    std::map<std::string,int> disMap() {
        std::map<std::string, int>tempMap{ {"C语言教程",10},{"STL教程",20} };
        return tempMap;
    }
    //调用 map 类模板的移动构造函数创建 newMap 容器
    std::map<std::string, int>newMap(disMap());

    4) map 类模板还支持取已建 map 容器中指定区域内的键值对,创建并初始化新的 map 容器。例如:

    std::map<std::string, int>myMap{ {"C语言教程",10},{"STL教程",20} };
    std::map<std::string, int>newMap(++myMap.begin(), myMap.end());

    5) 当然,在以上几种创建 map 容器的基础上,我们都可以手动修改 map 容器的排序规则。默认情况下,map 容器调用 std::less<T> 规则,根据容器内各键值对的键的大小,对所有键值对做升序排序。

    因此,如下 2 行创建 map 容器的方式,其实是等价的:

    std::map<std::string, int>myMap{ {"C语言教程",10},{"STL教程",20} };
    std::map<std::string, int, std::less<std::string> >myMap{ {"C语言教程",10},{"STL教程",20} };

    以上 2 中创建方式生成的 myMap 容器,其内部键值对排列的顺序为:

    <"C语言教程", 10>
    <"STL教程", 20>

    下面程序手动修改了 myMap 容器的排序规则,令其作降序排序:

    std::map<std::string, int, std::greater<std::string> >myMap{ {"C语言教程",10},{"STL教程",20} };

    此时,myMap 容器内部键值对排列的顺序为:

    <"STL教程", 20>
    <"C语言教程", 10>

     

    C++ map容器包含的成员方法

    成员方法 功能
    begin() 返回指向容器中第一个(注意,是已排好序的第一个)键值对的双向迭代器。如果 map 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。
    end() 返回指向容器最后一个元素(注意,是已排好序的最后一个)所在位置后一个位置的双向迭代器,通常和 begin() 结合使用。如果 map 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。
    rbegin() 返回指向最后一个(注意,是已排好序的最后一个)元素的反向双向迭代器。如果 map 容器用 const 限定,则该方法返回的是 const 类型的反向双向迭代器。
    rend() 返回指向第一个(注意,是已排好序的第一个)元素所在位置前一个位置的反向双向迭代器。如果 map 容器用 const 限定,则该方法返回的是 const 类型的反向双向迭代器。
    cbegin() 和 begin() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的键值对。
    cend() 和 end() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的键值对。
    crbegin() 和 rbegin() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的键值对。
    crend() 和 rend() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的键值对。
    find(key) 在 map 容器中查找键为 key 的键值对,如果成功找到,则返回指向该键值对的双向迭代器;反之,则返回和 end() 方法一样的迭代器。另外,如果 map 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。
    lower_bound(key) 返回一个指向当前 map 容器中第一个大于或等于 key 的键值对的双向迭代器。如果 map 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。
    upper_bound(key) 返回一个指向当前 map 容器中第一个大于 key 的键值对的迭代器。如果 map 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。
    equal_range(key) 该方法返回一个 pair 对象(包含 2 个双向迭代器),其中 pair.first 和 lower_bound() 方法的返回值等价,pair.second 和 upper_bound() 方法的返回值等价。也就是说,该方法将返回一个范围,该范围中包含的键为 key 的键值对(map 容器键值对唯一,因此该范围最多包含一个键值对)。
    empty()  若容器为空,则返回 true;否则 false。
    size() 返回当前 map 容器中存有键值对的个数。
    max_size() 返回 map 容器所能容纳键值对的最大个数,不同的操作系统,其返回值亦不相同。
    operator[] map容器重载了 [] 运算符,只要知道 map 容器中某个键值对的键的值,就可以向获取数组中元素那样,通过键直接获取对应的值。
    at(key) 找到 map 容器中 key 键对应的值,如果找不到,该函数会引发 out_of_range 异常。
    insert() 向 map 容器中插入键值对。
    erase() 删除 map 容器指定位置、指定键(key)值或者指定区域内的键值对。后续章节还会对该方法做重点讲解。
    swap() 交换 2 个 map 容器中存储的键值对,这意味着,操作的 2 个键值对的类型必须相同。
    clear() 清空 map 容器中所有的键值对,即使 map 容器的 size() 为 0。
    emplace() 在当前 map 容器中的指定位置处构造新键值对。其效果和插入键值对一样,但效率更高。
    emplace_hint() 在本质上和 emplace() 在 map 容器中构造新键值对的方式是一样的,不同之处在于,使用者必须为该方法提供一个指示键值对生成位置的迭代器,并作为该方法的第一个参数。
    count(key) 在当前 map 容器中,查找键为 key 的键值对的个数并返回。注意,由于 map 容器中各键值对的键的值是唯一的,因此该函数的返回值最大为 1。
    展开全文
  • map容器

    2020-07-01 16:29:16
    map容器 map的介绍 map 字典 映射 map是一个关系式容器,以模版的方式实现。 map的底层是一个红黑树结构 map由键(key)和值(value)组成 map里所有的key都是有序的,并且不会存在重复。 map的特点 map是一个容器,...

    map容器

    map的介绍

    map 字典 映射
    map是一个关系式容器,以模版的方式实现。
    map的底层是一个红黑树结构
    map由键(key)和值(value)组成
    map里所有的key都是有序的,并且不会存在重复。

    map的特点

    map是一个容器,容器里面存放元素,把这个元素分成两个逻辑块。
    第一个逻辑块叫key,第二个逻辑块叫value,他们一一对应。这两个区块当成一个组来管理。
    每一个节点的内容都是由一个pair<key,value>构成。
    

    map的基本操作

    原型是一个类模版:

    template <template k,template v>
    class pair{
    public:
    k first;
    v seconed;
    pair(k& first,v& seconed):first(first),seconed(seconed){}
    }
    //通过函数构造 
    pair<K,V> make_pair(K key,V value);
    

    初始化

    map<int,string> m;
    map<int,string>m={3,“wangwu”}

    插入数据:

        m.insert(pair<int,string>(66,"zhangsan");
        m.insert(make_pair(67, "张三"));
        m.insert({69,"李四"});
    

    访问数据:

        cout<<m.at(66)<<endl;
        cout<<m[66]<<endl;
    

    注意,at不能修改数据,【】能修改数据,但使用【】时可能会产生新的节点,容易发生错乱,所以,一般来说只用【】来修改数据。如果,【】修改数据时没有找到key,则会新增一个节点。

     m[66]=("小明");
    

    【】和insert的区别;
    insert不能够插入重复的数据,如果数据重复了,就插入无效。
    【】能够插入重复的数据,如果插入重复的数据,则修改原本的数据。

    迭代器操作

    map迭代器不能进行 + 和 - 运算符操作
    可以使用 ++ – 运算符进行遍历

    map常见用途

    1. 需要建立字符串与整数之间映射关系
    2. 通过一个唯一的key来建立存储关系的
    //for循环遍历 
    for(map<T1,T>::iterator iter=m.begin();iter!=end();iter++)
    { cout<<iter->first<<":"<<iter->seconed<<endl; }
    //foreach遍历 
    for (auto e:map)
    { cout<<e.first<<":"<<e.seconed<<endl; } 
    

    map的基本操作函数

    //插入一个元素
    	void insert()	
    	m.erase(55);
        //查找一个元素;
        m.find(66);
        //通过key访问或修改数据
        m.at(66);
        iterator begin(); //返回指向map头部的迭代器
        iterator end(); //返回指向map末尾的迭代器
        reverse_iterator rbegin(); //返回一个指向map尾部的逆向迭代器
        reverse_iterator rend(); //返回一个指向map头部的逆向迭代器
        const_reverse_iterator crbeing();
        const_reverse_iterator crend();
        int size(); // 返回map中元素的个数
        long max_size(); // 返回可以容纳的最大元素个数
        void clear(); // 删除所有元素
        int count(); // 返回指定key出现的次数 map中key只会出现一次,所以只会返回1或者 是0
        void empty(); // 判断容器是否为空,如果map为空则返回true
        void swap(); // 交换两个map内的元素
        void lower_bound(); // 返回键值>=给定元素的第一个位置
        void upper_bound(); // 返回键值>给定元素的第一个位置
        void get_allocator(); // 返回map的配置器
        void equal_range(); // 返回特殊条目的迭代器对
        void key_comp(); // 返回比较元素key的函数
        void value_comp(); // 返回比较元素value的函数
    

    map的优点:

    有序性:map的底层是红黑树自身是有序的,不停的插入元素,总是获得有序的数据。
    时间复杂度低:底层结构为红黑树,红黑树的很多操作都是在log(n)的时间复杂度下实现的 ,因此效率高。
    缺点:空间占用率高,红黑树的关系,每一个节点都需要额外保存,这样使得每一个节点都需要大量空间。

    multimap 多表映射

    特点:
    key的值可以重复,key的值仍然会排序;
    不可以通过键的值进行访问
    不可以at()
    不可以operator[]

    unordered_map 无序映射

    #include<unordered_map>
    特点:
    key的值不会重复,key的值不会排序,但是会去重。
    优点:内部的结构是哈希表,查找0(1),效率高。
    缺点:哈希表的建立耗费时间。
    应用场景:对于频繁的查找,用unordered_map更高效。
    底层是一个哈希表值。
    unordered_map记录元素的hash值,根据hash值判断元素是否相同。

    函数操作:

    与map的函数操作基本一致。

    unordered_multimp 无序多表映射

    特点:
    该容器既不排序也不去重。
    底层是一个哈希表
    用法与map相似。
    虽然不会排序,但是重复的数据会被排列在一起。

    集合set

    头文件#include #include <unordered_set>

    set容器:

    set容器相比其他容器,没有value值,而只有key值

    总结

    熟悉map,multimap,unorderd_multimap,unordered_map,set的特点,优点,缺点,底层实现。
    熟悉map,multimap,unorderd_multimap,unordered_map,set的函数操作。
    了解迭代器输出。
    在这里插入图片描述

    展开全文
  • Map容器

    千次阅读 2009-05-16 21:18:00
    Map容器map类定义了一个关联容器,并且在容器中使用唯一的关键字来映射相应的值。例如: A 0 B 1 C 2 从本质上来说,关键字就是值的名字。在map对象中存储了一个值之后,就可以通过关键字来获得它。map对象是...

                          Map容器
    map类定义了一个关联容器,并且在容器中使用唯一的关键字来映射相应的值。

    例如:
         A     0
                B     1
                C     2 
    从本质上来说,关键字就是值的名字。在map对象中存储了一个值之后,就可以

    通过关键字来获得它。map对象是一系列关键字/值的匹配对。
    map的主要功能在于:只有你知道了一个值的关键字,就能够找到这个值。   例

    如:
        定义一个map对象m,在该对象中使用人名作为关键字,并将每个人的电话号

    码存储为值。那么可以使用
                          m[“张三”]
        表示张三的电话号码。
    从前面的例子可以看出map类有一个非常优越的特点:关联数组。在普通的数组

    中,索引是一个整数。而在关联数组中,索引是一个键,并且键可以是任意类型

    的,可以是String、double、int类型,甚至可以是一些用户定义的类。
    如: m[“张三”] = 8123456
    定义一个map对象
     
                 map<char, int>m;
    定义一个map对象的迭代器
     
                 map<char, int>::iterator p;
    使用迭代器访问map
         
                 p = m.begin();
                 p++;
                 p = m.end();
    m.insert(pair<char, int> (‘A’, 0))

                 p->first
                 p->second查找map对象中的关键字
         
             p = m.find(‘H’) ;
             p -> first;
             p -> second;
    使用map对象求下面问题:读取输入数据(文具,数量),输入以end结束。输出各

    种文具(排序)的总数和总文具数量, 
        输入
        pen             17
        pencil         23
        rubber       38
        pen             15
        ruler           9
        compasses  20
        ruler           10
        end
    输出
        compasses   20
        pen              32
        pencil          23
        rubber        38
        ruler           19
        total            132
    程序代码为:
    #include<iostream>
    #include<map>
    #include<fstream>
    #include<string>
    using namespace std;
    void main()
    {
        string str;
     int number,total=0;
        ifstream stream("input.txt");
     stream>>str>>number;
     total=number;
        //typedef map<string,int , less<int> > INT2STRING;
     //INT2STRING mp;
     map<string,int>mp;
     
        //mp.insert(INT2STRING::value_type(str,number));
       
     if(str!="end")
     {  
      map<string,int>::iterator p=mp.begin(),q=mp.begin();
        
            mp.insert(pair<string,int>(str,number));
         while(str!="end")
      {  
       stream>>str;
          if(str!="end")
       {
            
                    stream>>number;
        total+=number;
              q=mp.find(str);
          if(q!=mp.end())
          {
               q->second+=number;
              
          }
         else
         {  
          p=mp.begin();
         for(int i=0;i<mp.size();i++)
         {
            
          if(p->first>str)
          {
                   mp.insert

    (p,pair<string,int>(str,number));
                               //p=mp.begin();
                 break;
           }
              else if(p->first<str)
           {
                   p++;
           }
         }//for
         if(i>=mp.size()){ mp.insert

    (pair<string,int>(str,number));}
                    
         }//else
         p=q=mp.begin();
       }//if
       else{  break;}
       
      }//while
      
     }//if
     map<string,int>::iterator m=mp.begin();
     for(int j=0;j<mp.size();j++)
     {
         cout<<m->first<<"  "<<m->second<<endl;
      m++;
     }
     cout<<"total"<<"  "<<total<<endl;
    }

    展开全文
  • C++map容器map容器排序

    2020-09-08 08:53:24
    C++map容器map容器排序 学习目标: map容器默认排序规则为 按照key值进行 从小到大排序,掌握如何改变排序规则 #include <iostream> #include <map> using namespace std; class MyCompare { public...

    C++map容器map容器排序

    学习目标:

    • map容器默认排序规则为 按照key值进行 从小到大排序,掌握如何改变排序规则
    #include <iostream>
    #include <map>
    using namespace std;
    
    class MyCompare 
    {
    public:
    	bool operator()(int val1, int val2)const
    	{
    		return val1 > val2;
    	}
    };
    
    void test01()
    {
    	//默认从小到大排序
    	//利用仿函数实现从大到小排序
    	map<int, int, MyCompare> m;
    
    	m.insert(make_pair(1, 10));
    	m.insert(make_pair(2, 20));
    	m.insert(make_pair(3, 30));
    	m.insert(make_pair(4, 40));
    	m.insert(make_pair(5, 50));
    
    	for (map<int, int, MyCompare>::iterator it = m.begin(); it != m.end(); ++it)
    	{
    		cout << "key = " << it->first << " value = " << it->second << endl;
    	}
    }
    int main()
    {
    	test01();
    	return 0;
    }
    //利用仿函数可以指定map容器的排序规则
    //对于自定义数据类型,map必须要指定排序规则,同set容器
    

    C++map容器map容器排序

    展开全文
  • C++ map容器和multimap容器(STL map容器

    万次阅读 多人点赞 2018-11-08 22:30:05
    1. 关联容器和map容器概述 2. map容器 2.1 map的创建以及初始化列表 2.2 map容器的一般常用属性(方法) 2.3 插入数据 2.4 数据的访问和遍历 2.5 数据的删除 2.6 map中关键词的排序 3. multimap容器 3.1 ...
  • 这篇结束学习map容器的API,通过学习map容器的排序,引出一个新的知识点:仿函数,然后继续学习仿函数相关的知识点。 1.map容器默认排序 我们知道map容器是该容器本身提供的sort()排序算法,不是直接调用全局...
  • C++ map 容器

    2010-11-12 23:26:33
    C++ map 容器 C++ map 容器 C++ map 容器 C++ map 容器 C++ map 容器 C++ map 容器 C++ map 容器
  • 接着学习map容器的常见API操作,依然是大部分前面学习过的,名称相同的API的基本调用测试。本篇学习map容器大小相关API,然后学习容器交换,容器元素插入和删除,清空等操作。 1.map容器大小操作 统计map容器大小...
  • C++map容器map大小和交换 功能描述: 统计map容器大小以及交换map容器 #include <map> #include <iostream> using namespace std; void printMap(map<int, int>& m) { for (map<int, ...
  • C++map容器map插入和删除 功能描述: map容器进行插入数据和删除数据 #include <iostream> #include <map> using namespace std; void printMap(map<int, int>& m) { for (map<int, ...
  • C++map容器map查找和统计 功能描述: 对map容器进行查找数据以及统计数据 #include <iostream> #include <map> using namespace std; void test() { map<int, int>m; m.insert(pair<int, ...
  • 简单介绍MAP容器

    2020-08-25 15:59:44
    1、map容器是什么? map是C++的一种标准容器,本质上是数据结构的一种。它可以提供很好的一对一(key-value)关系,类似hash表,可以实现高效的增删改查功能,在很多代码中使用map可以起到事半功倍的效果。 map容器...
  • C++ STL map容器详解

    2020-07-20 23:40:37
    目录创建C++ map容器的几种方法C++ map容器包含的成员方法C++ STL map容器迭代器用法详解C++ STL map获取键对应值的几种方法(超详细)C++ STL map insert()插入数据的4种方式C++ STL map emplace()和emplace_hint()...
  • map容器用法总结

    2019-08-11 20:07:19
    一、骚操作 ...1、map容器实现对元素进行计数。 使用方法:定义一个双类型的map容器map<string,ll> mp;,第一个用来存元素,第二个用来计数。 使用示例见https://mp.csdn.net/postedit/99222398 ...
  • C++ map容器用法

    万次阅读 2018-09-22 20:09:01
    C++ map容器用法   介绍 Map是键-值对的集合,map中的所有元素都是pair,可以使用键作为下标来获取一个值。Map中所有元素都会根据元素的值自动被排序,同时拥有实值value和键值key,pair的第一元素被视为键值,...
  • 关于map容器

    2014-02-18 10:57:55
    map容器的键值会自动排序
  • map容器的查找

    2020-07-20 15:12:59
    map容器中,有两种常用的查找方式,都是寻关键码访问,分别为find(key)和下标[key],其中find函数若没有查找到这个关键码,则返回尾迭代器map.end();若查找到则返回该关键码的迭代器。[]下标是直接按照关键码取查找...
  • map容器设计

    2014-04-29 09:16:14
    在红黑树基础上设计map容器,在设计map时,可以明显利用的map模板类中KEY,VALUE,KEYOFVALUE的灵活运用 不多说,代码如下: //my_map.h #ifndef MY_MAP_H_INCLUDED #define MY_MAP_H_INCLUDED #include //for pair ...
  • C++ STL map容器迭代器遍历 标准库为 map 容器配备的是双向迭代器(bidirectional iterator)。这意味着,map 容器迭代器只能进行 ++p、p++、–p、p–、*p 操作,并且迭代器之间只能使用 == 或者 != 运算符进行比较...
  • C++STL之map容器

    千次阅读 多人点赞 2018-08-08 21:12:08
    map容器的数据结构也采用红黑树来实现的,插入元素的键值不允许重复,比较函数只对元素的键值进行 比较,元素的各项数据可通过键值检索出来。由于map与set采用的都是红黑树的结构,所以,用法基本相似。  ...
  • map容器的遍历

    2016-11-02 15:57:21
    在用列表时用到了map容器,,他的遍历是这样的: for(auto allianceInfo:map){ (中间赋值用:auto name=map.second.szName) }
  • 2.7map容器类型

    千次阅读 2016-11-14 20:32:26
    1.map容器类型及map类概述 map的本意是映射,就是可以将一个量映射到另一个量。比如将一个字符串映射为一个数值,那这个字符串就是map的键(key),那个值就是map的数据(value)。 map类的所有对象具有3种属性 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,999
精华内容 9,599
关键字:

map容器