c++ list, vector, map, set 区别与用法比较

List封装了链表,Vector封装了数组,
list和vector得最为重大的分在于vector使用连续内存存储的,他支持[]运算符,而list是为链表形式落实之,不支持[]。

Vector对于自由走访的速快速,但是对于插入尤其是于首插入元素速度很缓慢,在尾部插入速度颇快。List对于自由访问速度慢得差不多,因为可能要遍历整个链表才会得,但是于插入就趁早的大多了,不待拷贝和运动数据,只需要改变指针的针对就是足以了。另外对新增长的元素,Vector有同一模拟算法,而List可以轻易加入。
Map,Set属于标准提到容器,使用了颇迅速之抵检索二叉树:红黑树,他的插入删除效率比较任何队容器高是因不欲开内存拷贝和内存移动,而直白调换指向节点的指针即可。
Set和Vector的界别在Set不包含重复的数额。Set和Map的区分在Set只含Key,而Map有一个Key和Key所对应的Value两个因素。
Map和Hash_Map的分是Hash_Map使用了Hash算法来加速查找过程,但是急需重新多的内存来存放在这些Hash桶元素,因此得以算是得上是利用空间来换取时间策略。

 

 

 

vector

    向量 相当给一个数组
   
在内存中分配一块连续的内存空间进行仓储。支持不点名vector大小的蕴藏。STL内部贯彻时,首先分配一个挺深的内存空间预备进行仓储,即capacituy()函数返回的深浅,当跨越这分配的半空中时更圆重新放分配一片内存存储,这叫丁因vector可以无点名vector即一个总是内存的大大小小的发。通常这个默认的内存分配会好大部分景下之贮存。
   优点:(1)
不指定同片内存大小的数组的连天存储,即好像数组一样操作,但可对这个数组
               进行动态操作。通常体现在push_back() pop_back()
               (2) 随机访问方便,即支持[ ]操作符和vector.at()
               (3) 节省空间。
   缺点:(1) 在内部进行扦插删除操作效率低。
               (2)
只会于vector的结尾进行push和pop,不克以vector的条进行push和pop。
               (3) 当动态增长的多寡超过vector默认分配的生时而进行完的重新分配、拷贝与释放
                     放 

list
    双向链表
   
每一个结点都囊括一个消息快Info、一个前任指针Pre、一个后驱指针Post。可以不分配要的内存大小方便的拓展添加和去操作。使用的是是非非连续的内存空间进行仓储。
   优点:(1) 不动连续内存完成动态操作。
               (2) 在中间福利的拓展扦插和去操作
               (3) 可当双边进行push、pop
   缺点:(1) 不可知开展内的随机走访,即无支持[ ]操作符和vector.at()
               (2) 相对于verctor占用内存多

deque
   双端队列 double-end queue
   deque是当效能及统一了vector和list。
   优点:(1) 随机访问方便,即支持[ ]操作符和vector.at()
               (2) 在中福利的开展扦插和去操作
               (3) 可当两边进行push、pop
   缺点:(1) 占用内存多

运用分别:

     1 如果你用快速之跟着存取,而未以乎插入和去的频率,使用vector 
     2 而你要大量之插入和去,而无体贴随即存取,则承诺下list 
     3 如果你需要就存取,而且关心两端数据的插和去,则答应采用deque

 

 

 

 

 

 

C++STL中vector容器的故法 

 

http://xiamaogeng.blog.163.com/blog/static/1670023742010102494039234/

 

vector是C++标准模板库中的组成部分内容,它是一个多力量的,能够操作多数码结构和算法的模板类和函数库。vector之所以被认为是一个器皿,是以其会像容器一样存放各种类型的靶子,简单地游说vector是一个能够存放任意档次的动态数组,能够增加及削减数量。为了好采用vector,必须在您的头文件被富含下面的代码:

#include <vector>

vector属于std命名域的,因此待经过命名限定,如下完成你的代码:

using std::vector;     vector<int> v;

抑或连在一起,使用人名:

std::vector<int> v;

提议用全局的命名域方式:

using namespace std;

1.vector的声明

   vector<ElemType> c;   创建一个空的vector

   vector<ElemType> c1(c2); 创建一个vector c1,并用c2错过初始化c1

   vector<ElemType> c(n) ;
创建一个含有n个ElemType类型数据的vector;

   vector<ElemType> c(n,elem);
创建一个暗含n个ElemType类型数据的vector,并尽方始化为elem;

   c.~vector<ElemType>(); 销毁所有数据,释放资源;

2.vector容器中常用之函数。(c为一个容器对象)

    c.push_back(elem);   在容器最后位置添加一个元素elem

    c.pop_back();            删除容器最后位置处在的因素

    c.at(index);                返回指定index位置处于之要素

    c.begin();                   返回指向容器最开头位置数据的指针

    c.end();                      返回指向容器最后一个数据单元的指针+1

    c.front();                     返回容器最开始单元数据的援

    c.back();                     返回容器最后一个数目的援

    c.max_size();              返回容器的最好特别容量

    c.size();                      返回时容器被实际上存放元素的个数

    c.capacity();               同c.size()

     c.resize();                   重新设置vector的容量

    c.reserve();                同c.resize()

    c.erase(p);              
删除指针p指向位置的数额,返回下本着下一个数目位置的指针(迭代器)

    c.erase(begin,end)    
删除begin,end区间的数额,返回指向下一个数目位置的指针(迭代器)

    c.clear();                    清除所有数据

    c.rbegin();                 
将vector反转后的起指针返回(其实就是原本的end-1)

    c.rend();                    
将vector反转后底了指针返回(其实就算是原先的begin-1)

    c.empty();                  
判断容器是否也空,若否空返回true,否则回false

    c1.swap(c2);               交换两个容器中之数量

    c.insert(p,elem);         
在指针p指向的位置插入数据elem,返回指向elem位置的指针       

    c.insert(p,n,elem);      在岗位p插入n个elem数据,无返回值

    c.insert(p,begin,end) 在职位p插入在区间[begin,end)的数,无返回值

3.vector丁的操作

    operator[] 如: c.[i];

    同at()函数的作用一样,即取容器中的多少。

以达成约讲述了vector类中所蕴涵的函数和操作,下面继续讨论什么利用vector容器;

1.数额的输入和去。push_back()与pop_back()

C++ 1
2.元素的造访

C++ 2
3.排序和询问

C++ 3

4.二维容器

C++ 4

C++ STLList队列用法(实例)

http://www.cnblogs.com/madlas/articles/1364503.html

 

C++ STL List队列用法(实例)

2007-12-15 12:54

#include <iostream>
#include <list>
#include <numeric>
#include <algorithm>

using namespace std;

//创建一个list容器的实例LISTINT
typedef list<int> LISTINT;

//创建一个list容器的实例LISTCHAR
typedef list<char> LISTCHAR;

void main(void)
{
    //————————–
    //用list容器处理整型数据
    //————————–
    //用LISTINT创建一个名叫也listOne的list对象
    LISTINT listOne;
    //声明i为迭代器
    LISTINT::iterator i;

    //从前面为listOne容器中上加多少
    listOne.push_front (2);
    listOne.push_front (1);

    //从后面向listOne容器中上加多少
    listOne.push_back (3);
    listOne.push_back (4);

    //从前向后显示listOne中的多寡
    cout<<“listOne.begin()— listOne.end():”<<endl;
    for (i = listOne.begin(); i != listOne.end(); ++i)
        cout << *i << ” “;
    cout << endl;

    //从晚朝后显示listOne中的数量
LISTINT::reverse_iterator ir;
    cout<<“listOne.rbegin()—listOne.rend():”<<endl;
    for (ir =listOne.rbegin(); ir!=listOne.rend();ir++) {
        cout << *ir << ” “;
    }
    cout << endl;

    //使用STL的accumulate(累加)算法
    int result = accumulate(listOne.begin(), listOne.end(),0);
    cout<<“Sum=”<<result<<endl;
    cout<<“——————“<<endl;

    //————————–
    //用list容器处理字符型数据
    //————————–

    //用LISTCHAR创建一个称作吧listOne的list对象
    LISTCHAR listTwo;
    //声明i为迭代器
    LISTCHAR::iterator j;

    //从前面为listTwo容器中补充加多少
    listTwo.push_front (‘A’);
    listTwo.push_front (‘B’);

    //从后面向listTwo容器中补充加多少
    listTwo.push_back (‘x’);
    listTwo.push_back (‘y’);

    //从前向后显示listTwo中之数据
    cout<<“listTwo.begin()—listTwo.end():”<<endl;
    for (j = listTwo.begin(); j != listTwo.end(); ++j)
        cout << char(*j) << ” “;
    cout << endl;

    //使用STL的max_element算法求listTwo中的极度特别要素并出示
    j=max_element(listTwo.begin(),listTwo.end());
    cout << “The maximum element in listTwo is:
“<<char(*j)<<endl;
}

#include <iostream>
#include <list>

using namespace std;
typedef list<int> INTLIST;

//从前向后显示list队排的成套素
void put_list(INTLISTlist, char *name)
{
    INTLIST::iterator plist;

    cout << “The contents of ” << name << ” : “;
    for(plist = list.begin(); plist != list.end(); plist++)
        cout << *plist << ” “;
    cout<<endl;
}

//测试list容器的职能
void main(void)
{
//list1对象开为空
    INTLIST list1;  
    //list2对象最初来10独价值为6之元素
    INTLIST list2(10,6);
    //list3对象最初来3单价值吗6的因素
    INTLIST list3(list2.begin(),–list2.end());

    //声明一个名为i的双向迭代器
    INTLIST::iterator i;

    //从前向后展示各list对象的素
    put_list(list1,”list1″);
    put_list(list2,”list2″);
    put_list(list3,”list3″);
   
//从list1序列后加加少只元素
list1.push_back(2);
list1.push_back(4);
cout<<“list1.push_back(2) andlist1.push_back(4):”<<endl;
    put_list(list1,”list1″);

//从list1序列前面添加少独要素
list1.push_front(5);
list1.push_front(7);
cout<<“list1.push_front(5)
andlist1.push_front(7):”<<endl;
    put_list(list1,”list1″);

//在list1序列中插数据
list1.insert(++list1.begin(),3,9);
cout<<“list1.insert(list1.begin()+1,3,9):”<<endl;
    put_list(list1,”list1″);

//测试引用类函数
cout<<“list1.front()=”<<list1.front()<<endl;
cout<<“list1.back()=”<<list1.back()<<endl;

//从list1序列的左右各移去一个素
list1.pop_front();
list1.pop_back();
cout<<“list1.pop_front() andlist1.pop_back():”<<endl;
    put_list(list1,”list1″);

//清除list1中的第2个元素
list1.erase(++list1.begin());
cout<<“list1.erase(++list1.begin()):”<<endl;
    put_list(list1,”list1″);

//对list2赋值并显示
list2.assign(8,1);
cout<<“list2.assign(8,1):”<<endl;
    put_list(list2,”list2″);

//显示序列的状态信息
cout<<“list1.max_size():
“<<list1.max_size()<<endl;
cout<<“list1.size(): “<<list1.size()<<endl;
cout<<“list1.empty(): “<<list1.empty()<<endl;

//list序列容器的运算
    put_list(list1,”list1″);
    put_list(list3,”list3″);
cout<<“list1>list3: “<<(list1>list3)<<endl;
cout<<“list1<list3: “<<(list1<list3)<<endl;

//对list1容器排序
list1.sort();
    put_list(list1,”list1″);
   
//结合处理
list1.splice(++list1.begin(),list3);
    put_list(list1,”list1″);
    put_list(list3,”list3″);
}

 

 

 

C++map 映照容器

 

http://www.cppblog.com/vontroy/archive/2010/05/16/115501.html

 

map映照容器的元素数据是一个键值和一个炫耀数据整合的,键值与照数据里面有一一映照的涉。
        map映照容器的数据结构是行使红黑树来兑现之,插入键值的要素不同意再,比较函数只针对素的键值进行比,元素的各数据可通过键值检索出来。
       
使用map容器需要头文件包含语句“#include<map>”,map文件呢蕴藏了针对multimap多重映照容器的定义。
        
1、map创建、元素插入和遍历访问
        
创map对象,键值与照数据的路由友好定义。在尚未点名比较函数时,元素的插入位置是按部就班键值由小到大插入到黑白树被去之,下面这序详细说明了争操作map容器。

 1C++ 5#include <map>
 2C++ 6#include <string>
 3C++ 7#include <iostream>
 4C++ 8
 5C++ 9using std :: cout ;
 6C++ 10using std :: endl ;
 7C++ 11using std :: string ;
 8C++ 12using std :: map ;
 9C++ 13
10C++ 14int main()
11C++ 15C++ 16C++ 17{
12C++ 18     //定义map对象,当前没有另外因素
13C++ 19     map<string,float> m ;
14C++ 20     
15C++ 21     //插入元素,按键值的由小到大放入黑白树被
16C++ 22     m[“Jack”] = 98.5 ;
17C++ 23     m[“Bomi”] = 96.0 ;
18C++ 24     m[“Kate”] = 97.5 ;
19C++ 25     
20C++ 26     //先前全部历元素
21C++ 27     map<string,float> :: iterator it ;
22C++ 28     for(it = m.begin() ; it != m.end() ; it ++)
23C++ 29C++ 30     C++ 31{
24C++ 32          cout << (*it).first << ” : ” << (*it).second << endl ;
25C++ 33     }
26C++ 34     
27C++ 35     return 0 ;
28C++ 36}
29C++ 37

        运行结果:
                          Bomi :96
                          Jack  :98.5
                          Kate  :97.5
        程序编译试,会起代号为“warning C4786” 的警戒, “4786”
是记符超长警告的代号。可以当程序的条文件包含代码的面前使用”#pragma
waring(disable:4786)”
宏语句,强制编译器忽略该警告。4786如泣如诉警告对先后的是和运转并随便影响。
2、删除元素
        map
照耀容器的 erase()
删除元素函数,可以去除某个迭代器位置及之要素、等于有键值的元素、一个迭代器区间上的有着因素,当然,也可采用clear()方法清空map映照容器。
        下面这个次演示了去map容器中键值为28底素:

 1C++ 38#include <map>
 2C++ 39#include <string>
 3C++ 40#include <iostream>
 4C++ 41
 5C++ 42using std :: cout ;
 6C++ 43using std :: endl ;
 7C++ 44using std :: string ;
 8C++ 45using std :: map ;
 9C++ 46
10C++ 47int main()
11C++ 48C++ 49C++ 50{
12C++ 51    //定义map对象,当前未曾其他因素
13C++ 52    map<int, char> m ;
14C++ 53    //插入元素,按键值的由小到大放入黑白树被
15C++ 54    m[25] = ‘m’ ;
16C++ 55    m[28] = ‘k’ ;
17C++ 56    m[10] = ‘x’ ;
18C++ 57    m[30] = ‘a’ ;
19C++ 58    //删除键值为28的素
20C++ 59    m.erase(28) ;
21C++ 60    //向前整整历元素
22C++ 61    map<int, char> :: iterator it ;
23C++ 62    for(it = m.begin() ; it != m.end() ; it ++)
24C++ 63C++ 64    C++ 65{
25C++ 66        //输出键值与照数据
26C++ 67        cout << (*it).first << ” : ” << (*it).second << endl ;
27C++ 68    }
28C++ 69    return 0 ;
29C++ 70}
30C++ 71

运转结果:
                     10 : x
                     25 : m
                     30 : a
3、元素反而往遍历
      可以用反向迭代器reverse_iterator反往遍历map映照容器中的数码,它用rbegin()方法以及rend()方法指出反向遍历的苗子位置与终止位置。

 1C++ 72#include <map>
 2C++ 73#include <string>
 3C++ 74#include <iostream>
 4C++ 75
 5C++ 76using std :: cout ;
 6C++ 77using std :: endl ;
 7C++ 78using std :: string ;
 8C++ 79using std :: map ;
 9C++ 80
10C++ 81int main()
11C++ 82C++ 83C++ 84{
12C++ 85    //定义map对象,当前无其余因素
13C++ 86    map<int, char> m ;
14C++ 87    //插入元素,按键值的由小到大放入黑白树被
15C++ 88    m[25] = ‘m’ ;
16C++ 89    m[28] = ‘k’ ;
17C++ 90    m[10] = ‘x’ ;
18C++ 91    m[30] = ‘a’ ;
19C++ 92    //反向一切历元素
20C++ 93    map<int, char> :: reverse_iterator rit ;
21C++ 94    for( rit = m.rbegin() ; rit != m.rend() ; rit ++)
22C++ 95C++ 96    C++ 97{
23C++ 98        //输入键值与照数据
24C++ 99        cout << (*rit).first << ” : ” << (*rit).second << endl ;
25C++ 100    }
26C++ 101    return 0 ;
27C++ 102}
28C++ 103

运行结果:
                  30 : a
                  28 : k
                  25 : m
                  10 : x
4、元素的检索
       
使find()方法来索某只键值,如果搜索到了,则归该键值所在的迭代器位置,否则,返回end()迭代器位置。由于map采用黑白树数据结构来兑现,所以找速度是不过快的。
       下面是次搜索键值为28的元素:

 1C++ 104#include <map>
 2C++ 105#include <string>
 3C++ 106#include <iostream>
 4C++ 107
 5C++ 108using std :: cout ;
 6C++ 109using std :: endl ;
 7C++ 110using std :: string ;
 8C++ 111using std :: map ;
 9C++ 112
10C++ 113int main()
11C++ 114C++ 115C++ 116{
12C++ 117    //定义map对象,当前从未有过其余因素
13C++ 118    map<int, char> m ;
14C++ 119    //插入元素,按键值的由小到大放入黑白树被
15C++ 120    m[25] = ‘m’ ;
16C++ 121    m[28] = ‘k’ ;
17C++ 122    m[10] = ‘x’ ;
18C++ 123    m[30] = ‘a’ ;
19C++ 124    map<int, char> :: iterator it ;
20C++ 125    it = m.find(28) ;
21C++ 126    if(it != m.end())  //搜索到拖欠键值
22C++ 127            cout << (*it).first << ” : ” << ( *it ).second << endl ;
23C++ 128    else
24C++ 129            cout << “not found it” << endl ;
25C++ 130    return 0 ;
26C++ 131}
27C++ 132

5、自定义比较函数
        
拿元素插入到map中错过之当儿,map会根据设定的可比函数将拖欠因素放到该放的节点上。在定义map的时,如果没有点名比较函数,那么以默认的于函数,即按照键值由小到大的一一插入元素。在群气象下,需要团结修比较函数。
        编写方法发生三三两两种植。
       
(1)如果元素不是结构体,那么,可以编写比较函数。下面这顺序编制的较规则是要求以键值由特别到多少之逐条将元素插入到map中

 1C++ 133#include <map>
 2C++ 134#include <string>
 3C++ 135#include <iostream>
 4C++ 136
 5C++ 137using std :: cout ;
 6C++ 138using std :: endl ;
 7C++ 139using std :: string ;
 8C++ 140using std :: map ;
 9C++ 141
10C++ 142//自定义比较函数 myComp
11C++ 143struct myComp
12C++ 144C++ 145C++ 146{
13C++ 147    bool operator() (const int &a, const int &b)
14C++ 148C++ 149    C++ 150{
15C++ 151        if(a != b) return a > b ;
16C++ 152        else  return a > b ;
17C++ 153    }
18C++ 154} ;
19C++ 155
20C++ 156int main()
21C++ 157C++ 158C++ 159{
22C++ 160    //定义map对象,当前从未有过外因素
23C++ 161    map<int, char> m ;
24C++ 162    //插入元素,按键值的由小到大放入黑白树被
25C++ 163    m[25] = ‘m’ ;
26C++ 164    m[28] = ‘k’ ;
27C++ 165    m[10] = ‘x’ ;
28C++ 166    m[30] = ‘a’ ;
29C++ 167    //使用前向迭代器中程序遍历map
30C++ 168    map<int, char,myComp> :: iterator it ;
31C++ 169    for(it = m.begin() ; it != m.end() ; it ++)
32C++ 170            cout << (*it).first << ” : ” << (*it).second << endl ;
33C++ 171    return 0 ;
34C++ 172}
35C++ 173

运作结果:
                  30 :a
                  28 :k
                  25 :m
                  10 :x
       (2)如果元素是结构体,那么,可以一直把比较函数写在组织体内。下面的主次详细说明了何等操作:

 1C++ 174#include <map>
 2C++ 175#include <string>
 3C++ 176#include <iostream>
 4C++ 177
 5C++ 178using std :: cout ;
 6C++ 179using std :: endl ;
 7C++ 180using std :: string ;
 8C++ 181using std :: map ;
 9C++ 182
10C++ 183struct Info
11C++ 184C++ 185C++ 186{
12C++ 187    string name ;
13C++ 188    float score ;
14C++ 189    //重载 “<”操作符,自定义排列规则
15C++ 190    bool operator < (const Info &a) const
16C++ 191C++ 192    C++ 193{
17C++ 194        //按score由良及稍微排列。如果假定加排列,使用“>”号即可
18C++ 195        return a.score < score ;
19C++ 196    }
20C++ 197} ;
21C++ 198
22C++ 199int main()
23C++ 200C++ 201C++ 202{
24C++ 203    //定义map对象,当前尚无其余因素
25C++ 204    map<Info, int> m ;
26C++ 205    //定义Info结构体变量
27C++ 206    Info info ;
28C++ 207    //插入元素,按键值的由小到大放入黑白树被
29C++ 208    info.name = “Jack” ;
30C++ 209    info.score = 60 ;
31C++ 210    m[info] = 25 ;
32C++ 211    info.name = “Bomi” ;
33C++ 212    info.score = 80 ;
34C++ 213    m[info] = 10 ;
35C++ 214    info.name = “Peti” ;
36C++ 215    info.score = 66.5 ;
37C++ 216    m[info] = 30 ;
38C++ 217    //使用前奔迭代器中程序遍历map
39C++ 218    map<Info,int> :: iterator it ;
40C++ 219    for(it = m.begin() ; it != m.end() ; it ++)
41C++ 220C++ 221    C++ 222{
42C++ 223            cout << (*it).second << ” : ” ;
43C++ 224            cout << ((*it).first).name << ” : ” << ((*it).first).score << endl ;
44C++ 225    }
45C++ 226    return 0 ;
46C++ 227}
47C++ 228

运行结果:
                  10 :Bomi   80
                  30 :Peti     66.5
                  25 :Jack    60
6、用map实现数字分别
      对数字的诸位进行分离,采用取余等数学方法是可怜耗时的。而把数字当成字符串,使用map的投功能,很方便地实现了数字分别。下面是顺序将一个字符串中的字符当成数字,并以各位的数值相加,最后输出各位的与。

 1C++ 229#include <string>
 2C++ 230#include <map>
 3C++ 231#include <iostream>
 4C++ 232
 5C++ 233using std :: cout ;
 6C++ 234using std :: endl ;
 7C++ 235using std :: string ;
 8C++ 236using std :: map ;
 9C++ 237
10C++ 238int main()
11C++ 239C++ 240C++ 241{
12C++ 242    //定义map对象,当前莫外因素
13C++ 243    map<char, int> m ;
14C++ 244
15C++ 245    //赋值:字符映射数字
16C++ 246    m[‘0’] = 0 ;
17C++ 247    m[‘1’] = 1 ;
18C++ 248    m[‘2’] = 2 ;
19C++ 249    m[‘3’] = 3 ;
20C++ 250    m[‘4’] = 4 ;
21C++ 251    m[‘5’] = 5 ;
22C++ 252    m[‘6’] = 6 ;
23C++ 253    m[‘7’] = 7 ;
24C++ 254    m[‘8’] = 8 ;
25C++ 255    m[‘9’] = 9 ;
26C++ 256C++ 257    /**//*点的10修赋值语句可使用下面这循环简化代码编写
27C++ 258    for(int j = 0 ; j < 10 ; j++)
28C++ 259    {
29C++ 260            m[‘0’ + j] = j ;
30C++ 261    }
31C++ 262    */
32C++ 263    string sa, sb ;
33C++ 264    sa = “6234” ;
34C++ 265    int i ;
35C++ 266    int sum = 0 ;
36C++ 267    for ( i = 0 ; i < sa.length() ; i++ )
37C++ 268            sum += m[sa[i]] ;
38C++ 269    cout << “sum = ” << sum << endl ;
39C++ 270    return 0 ;
40C++ 271}
41C++ 272

7、数字映照字符的map写法
      
以无数景下,需要实现用数字映射为对应的字符,看看下面的主次:

 1C++ 273#include <string>
 2C++ 274#include <map>
 3C++ 275#include <iostream>
 4C++ 276
 5C++ 277using std :: cout ;
 6C++ 278using std :: endl ;
 7C++ 279using std :: string ;
 8C++ 280using std :: map ;
 9C++ 281
10C++ 282int main()
11C++ 283C++ 284C++ 285{
12C++ 286    //定义map对象,当前没有其它因素
13C++ 287    map<int, char> m ;
14C++ 288
15C++ 289    //赋值:字符映射数字
16C++ 290    m[0] = ‘0’ ;
17C++ 291    m[1] = ‘1’ ;
18C++ 292    m[2] = ‘2’ ;
19C++ 293    m[3] = ‘3’ ;
20C++ 294    m[4] = ‘4’ ;
21C++ 295    m[5] = ‘5’ ;
22C++ 296    m[6] = ‘6’ ;
23C++ 297    m[7] = ‘7’ ;
24C++ 298    m[8] = ‘8’ ;
25C++ 299    m[9] = ‘9’ ;
26C++ 300C++ 301    /**//*点的10条赋值语句可利用下面是循环简化代码编写
27C++ 302    for(int j = 0 ; j < 10 ; j++)
28C++ 303    {
29C++ 304            m[j] = ‘0’ + j ;
30C++ 305    }
31C++ 306    */
32C++ 307    int n = 7 ;
33C++ 308    string s = “The number is ” ;
34C++ 309    cout << s + m[n] << endl ;
35C++ 310    return 0 ;
36C++ 311}
37C++ 312

运作结果:
                  The number is 7

 

 

 

 

 

 

 

 

 

 

 

 

遵循模板库就是看似及函数模板的雅集合。STL共来6种植组件:容器,容器适配器,迭代器,算法,函数对象同函数适配器。

1、容器:

容器是用来存储和团其余对象的靶子。STL容器类的模版在标准头文件被定义。主要如下所示

C++ 313

①队列容器

主导的序列容器是方图被的前方三近似:

C++ 314

有关三者的利害主要是:

A:vector<T>矢量容器:可以随便访问容器的情节,在排末尾添加或删除对象,但是因是打尾部删除,过程格外慢,因为必须走插入或删除点后面的享有目标。

C++ 315

 

矢量容器的操作:(自己原先发个说明,贴出大家看)

C++ 316

其中的capacity表示容量,size是眼前数个数。矢量容器如果用户增长一个元素时容量已经满,那么即便长时容量的一半底内存,比如现在是500了,用户添加进第501只,那么他会重开发250个,总共就750个了。所以矢量容器当你补充加数据量很可怜之时段,需要留意这同一碰啊。。。

 

苟想用迭代器访问元素是比较简单的,使用迭代器输出元素的轮回类似如下:

 

[cpp] view
plaincopy

 

 

  1. vector<int>::iterator表示矢量容器vector<int>的迭代器。。。  

[cpp] view
plaincopy

 

 

  1. for(vector<int>::iterator iter = number.begin(); iter<number.end(); iter++)//这里的iterator iter算是一个指南针了  
  2.      cout << ” ” << *iter;  

本也得以据此我们温馨的办法,但是感觉用者的重新好有的。

 

 

[cpp] view
plaincopy

 

 

  1. for(vector<int>::size_type i=0; i<number.size(); i++)  
  2.     cout << ” ” << number[i]  

 

 

排序矢量元素:

本着矢量元素的排序可以动用<algorithm>头文件中定义之sort()函数模板来针对一个矢量容器进行排序。但是出几触及要求要留意

 

  1. sort()函数模板用<运算符来排列元素的次第,所以容器被目标要得展开<运算,如果是骨干类型,可以直接调用sort(),如果是自从定义对象,必须对<进行演算符重载
  2. 区区单迭代器的针对必须是行的首先只目标同终极一个目标的生一个岗位。比如:sort(people.begin(),
    people.end());//这里少单参数就是迭代器的意了

B:deque<T>容器:非常相近vector<T>,且支持相同的操作,但是她还可于班开头加上和去。

C++ 317

 

deque<T>双端队列容器与矢量容器基本接近,具有相同之函数成员,但是多少不同的是它们支持于双方插入和去数据,所以就发生矣少数只函数:push_front和pop_front。并且有点儿独迭代器变量

 

[cpp] view
plaincopy

 

 

  1. <span style=”font-size:18px;”>#include <deque>  
  2. deque<int> data;//创建双端队列容器对象  
  3. deque<int>::iterator iter;//书序迭代器  
  4. deque<int>::reverse_iterator riter;//逆序迭代器。  
  5. //iter和riter是见仁见智之项目</span>  

 

C:list<T>容器是双料朝着链表,因此可中之在外位置添加和去。列表的先天不足是勿可知随意访问内容,要惦记访问内容要在列表的其中从头开始便利内容,或者由尾部开始。

C++ 318

 

 

②事关容器

map<K,
T>映射容器:K表示键,T表示对象,根据特定的键映射到目标,可以开展高效的探寻。

至于其的创导及查找的操作作如下总结

 

[cpp] view
plaincopy

 

 

  1. //创建映射容器  
  2. map<person, string> phonebook;  
  3.   
  4. //创建而存储的靶子  
  5. pair<person, string> entry = pair<person, string>(person(“mel”, “Gibson”), “213 345 567”);  
  6.   
  7. //插入对象  
  8. phonebook.insert(entry);//只要照中从未一样之键,就足以插入entry  
  9.   
  10. //访问对象  
  11. string number = phonebook[person(“mel”, “Gibson”)];//如果这个键不设有,会默认将是键插入  
  12.   
  13. //如果未思以找不至的时刻插入,可以先查找然后又寻觅  
  14. person key = person(“mel”, “Gibson”);  
  15. map<person, string>::iterator iter = phonebook.find(key);//创建迭代器,就当是指针就吓了  
  16.   
  17. if(iter != phonebook.end())  
  18.     string  number = iter->second;  

C++ 319

 

 

 

2、容器适配器:

容器适配器是包裹了现有的STL容器类的模板类,提供了一个不同之、通常还产生限制性的效益。具体如下所示

C++ 320

 

A:queue<T>队列容器:通过适配器实现先进先出的贮存机制。我们不得不望行的结尾添加或于初步删除元素。push_back()
pop_front()

代码:queue<string, list<string> >
names;(这就算是概念之一个适配器)是依据列表创建行的。适配器模板的次只类别形参指定要动的脚序列容器,主要的操作如下

C++ 321

C++ 322

B:priority_queue<T>优先级列容器:是一个序列,它的顶部总是有着最深还是高优先级。优先级列容器与队列容器一个不同点是预先级列容器不能够访问队列后端平的素。

默认情况下,优先级列适配器类使用的是矢量容器vector<T>,当然好选指定不同的行列容器作为基础,并选择一个备用函数对象来规定因素的先级代码如下

 

[cpp] view
plaincopy

 

 

  1. priority_queue<int, deque<int>, greate<int>> numbers;  

C:stack<T>堆栈容器:其适配器模板在<stack>头文件中定义,默认情况下基于deque<T>容器实现向下推栈,即后进先出机制。只能看以来刚上的目标

 

 

[cpp] view
plaincopy

 

 

  1. <span style=”font-size:18px;”>//定义容器  
  2. stack<person> people;  
  3. //基于列表来定义堆栈  
  4. stack<string, list<string>> names;</span>  

基本操作如下:

 

C++ 323

 

3、迭代器:

具体它的意还不曾怎么看明白,书及介绍迭代器的表现以及指针类似,这里开只记C++ 324,看看后面的例证再吃来实际的解释

切切实实分为三独片:输入流迭代器、插入迭代器和出口流迭代器。

C++ 325

C++ 326

在押即同样段的情节看的自身生硌堵了都,摘段课本介绍的始末,还是可以扶持了解的

<iterator>头文件中定义了迭代器的几乎单模板:①流迭代器作为对输入或输出流的指针,他们得为此来当流和任何利用迭代器或目的地中传输数据。②插入迭代器可以以数据传给一个主导序列容器。头文件被定义了个别独流迭代器模板:istream_iterator<T>用于输入流,ostream_iterator<T>用于输出流。T表示从流中提取数据还是摹写及流中的靶子的品类。头文件还定义了三只插入模板:insert<T>,
back_insert<T>和front_inset<T>。其中T也是指代表序列容器中数的花色。

输入流迭代器用底的程序来说明下,可见具体注释

 

[cpp] view
plaincopy

 

 

  1. #include <iostream>    
  2. #include <vector>  
  3. #include <numeric>  
  4. #include <sstream>  
  5.   
  6. using namespace std;    
  7.    
  8. int main()  
  9. {  
  10.     //定义矢量容器  
  11.     vector<int> numbers;  
  12.     cout << “请输入整数价值,以字母结束:”;  
  13.   
  14.     //定义输入流迭代器。注意少单例外  
  15.     //1、numberInput(cin)是指定迭代器指向流cin  
  16.     //2、numbersEnd没有点名,是默认的,默认构造了一个end_of_stream的迭代器,它等价于调用end()  
  17.     istream_iterator<int> numbersInput(cin), numbersEnd;  
  18.   
  19.     //用户输入,直到输入的不是int类型或者终止时为止。   
  20.     while(numbersInput != numbersEnd)  
  21.         numbers.push_back(*numbersInput++);  
  22.   
  23.     cout << “打印输出:” << numbers.at(3) << endl;  
  24.   
  25.   
  26.     //如何指定输入流呢?  
  27.       
  28.     //确定字符串  
  29.     string data(“2.1 3.6 36.5 26 34 25 2.9 63.8”);  
  30.   
  31.     //指定data为输入流input。需要头文件<sstream>  
  32.     istringstream input(data);  
  33.   
  34.     //定义迭代器  
  35.     istream_iterator<double> begin(input), end;  
  36.   
  37.     //计算数值与。  
  38.     //acculumate为头文件<numeric>下定义的函数。  
  39.     //第一只参数是开迭代器,第二独凡是终止迭代器(最后一个价的生一个)。第三单凡是跟底初值,注意得用0.0,用她规定数据类型是double  
  40.     cout << “打印数据的总数:” << accumulate(begin, end, 0.0) << endl;  
  41. }  

输出结果:

C++ 327

耽误时间太多。以后还写吧

 

4、算法:

算法是操作迭代器提供的一致组对象的STL函数模板,对目标的一个操作,可以跟前的器皿迭代器结合起来看。如下图介绍

C++ 328

5、函数对象:

函数对象是重载()运算符的类类型的对象。就是实现operator()()函数。

函数对象模板在<functional>头文件被定义,必要常常我们为可定义自己之函数对象。做只记C++ 329,等产生现实实例来进展更的诠释。

6、函数适配器:

函数适配器是容合并函数对象为生一个再扑朔迷离的函数对象的函数模板。

 

 

 

Map是STL的一个涉嫌容器,它提供一对一(其中第一单可称作关键字,每个重点字只能于map中出现同等赖,第二独或称为该要字之值)的数量处理能力,由于斯特点,它成功有或于咱们处理同对相同数码的时节,在编程上提供快速通道。这里说下map内部数据的团组织,map内部自盖平发红黑树(一种植不严加意义及之抵二叉树),这颗树有对数码自动排序的法力,所以在map内部所有的数目还是雷打不动的,后止我们会识到有序的补。

下举例说明什么是相当的数量映射。比如一个班级中,每个学员的学号和他的真名即便有正在相继映射的关联,这个模型用map可能无限制描述,很明显学号之所以int描述,姓名用字符串描述(本篇文章被不用char
*来叙述字符串,而是使用STL中string来讲述),下面让出map描述代码:

Map<int, string> mapStudent;

1.       map的构造函数

map共提供了6只构造函数,这块涉及到内存分配器这些事物,略过无表明,在底下我们以触发到有的map的构造方法,这里而说生之就算是,我们平常用如下方法组织一个map:

Map<int, string> mapStudent;

2.       数据的插

在构造map容器后,我们便足以往里插入数据了。这里讲三种插入数据的不二法门:

先是种:用insert函数插入pair数据,下面举例说明(以下代码虽然是随手写的,应该可以当VC和GCC下编译通过,大家可以运行下看什么作用,在VC下要入这长达语句,屏蔽4786告诫 #pragma
warning (disable:4786) )

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

       Map<int, string> mapStudent;

       mapStudent.insert(pair<int, string>(1, “student_one”));

       mapStudent.insert(pair<int, string>(2, “student_two”));

       mapStudent.insert(pair<int, string>(3, “student_three”));

       map<int, string>::iterator  iter;

       for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)

{

       Cout<<iter->first<<”   ”<<iter->second<<end;

}

}

亚种植:用insert函数插入value_type数据,下面举例说明

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

       Map<int, string> mapStudent;

       mapStudent.insert(map<int, string>::value_type (1,
“student_one”));

       mapStudent.insert(map<int, string>::value_type (2,
“student_two”));

       mapStudent.insert(map<int, string>::value_type (3,
“student_three”));

       map<int, string>::iterator  iter;

       for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)

{

       Cout<<iter->first<<”   ”<<iter->second<<end;

}

}

老三种植:用数组方式插入数据,下面举例说明

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

       Map<int, string> mapStudent;

       mapStudent[1] =  “student_one”;

       mapStudent[2] =  “student_two”;

       mapStudent[3] =  “student_three”;

       map<int, string>::iterator  iter;

       for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)

{

       Cout<<iter->first<<”   ”<<iter->second<<end;

}

}

上述三栽用法,虽然还可以实现数量的插,但是她是产生分之,当然了第一栽及第二种植于效力达到是成就同样的,用insert函数插入数据,在数据的插入上干到聚集的唯一性这个定义,即当map中来其一根本字时,insert操作是插数据未了的,但是之所以数组方式尽管不同了,它可挂以前拖欠要字对应的价值,用程序说明

mapStudent.insert(map<int, string>::value_type (1,
“student_one”));

mapStudent.insert(map<int, string>::value_type (1,
“student_two”));

方这有限久告词执行后,map中1这个第一字对应的价是“student_one”,第二长告句并无立竿见影,那么就即涉嫌到我们怎么掌握insert语句是否插入成功之题材了,可以为此pair来取得是否插入成功,程序如下

Pair<map<int, string>::iterator, bool> Insert_Pair;

Insert_Pair = mapStudent.insert(map<int, string>::value_type (1,
“student_one”));

俺们经过pair的次只变量来解是不是插入成功,它的首先个变量返回的凡一个map的迭代器,如果插入成功之言语Insert_Pair.second应该是true的,否则为false。

下为来好代码,演示插入成功与否问题

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

       Map<int, string> mapStudent;

Pair<map<int, string>::iterator, bool> Insert_Pair;

       Insert_Pair = mapStudent.insert(pair<int, string>(1,
“student_one”));

       If(Insert_Pair.second == true)

       {

              Cout<<”Insert Successfully”<<endl;

       }

       Else

       {

              Cout<<”Insert Failure”<<endl;

       }

       Insert_Pair = mapStudent.insert(pair<int, string>(1,
“student_two”));

       If(Insert_Pair.second == true)

       {

              Cout<<”Insert Successfully”<<endl;

       }

       Else

       {

              Cout<<”Insert Failure”<<endl;

       }

       map<int, string>::iterator  iter;

       for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)

{

       Cout<<iter->first<<”   ”<<iter->second<<end;

}

}

世家可用如下程序,看下用数组插入在数额覆盖上的法力

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

       Map<int, string> mapStudent;

       mapStudent[1] =  “student_one”;

       mapStudent[1] =  “student_two”;

       mapStudent[2] =  “student_three”;

       map<int, string>::iterator  iter;

       for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)

{

       Cout<<iter->first<<”   ”<<iter->second<<end;

}

}

3.       map的大小

以向map里面插入了数量,我们怎么理解当前曾插入了有点数量也,可以为此size函数,用法如下:

Int nSize = mapStudent.size();

4.       数据的遍历

此处吧供三栽办法,对map进行遍历

先是种:应用前奔迭代器,上面举例程序中处处都是了,略过不表明

老二栽:应用反相迭代器,下面举例说明,要体会效果,请从个动手运行程序

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

       Map<int, string> mapStudent;

       mapStudent.insert(pair<int, string>(1, “student_one”));

       mapStudent.insert(pair<int, string>(2, “student_two”));

       mapStudent.insert(pair<int, string>(3, “student_three”));

       map<int, string>::reverse_iterator  iter;

       for(iter = mapStudent.rbegin(); iter != mapStudent.rend();
iter++)

{

       Cout<<iter->first<<”   ”<<iter->second<<end;

}

}

老三栽:用数组方式,程序说明如下

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

       Map<int, string> mapStudent;

       mapStudent.insert(pair<int, string>(1, “student_one”));

       mapStudent.insert(pair<int, string>(2, “student_two”));

       mapStudent.insert(pair<int, string>(3, “student_three”));

       int nSize = mapStudent.size()

//此处发生无意,应该是 for(int nIndex = 1; nIndex <= nSize; nIndex++) 

//by rainfish

       for(int nIndex = 0; nIndex < nSize; nIndex++)

{

       Cout<<mapStudent[nIndex]<<end;

}

}

5.       数据的探寻(包括判定这根本字是否以map中出现)

于此处我们拿体会,map在数据插入时保证平稳的补。

若认清一个数额(关键字)是否在map中出现的章程较多,这里标题则是数据的觅,在此用过插在大量的map基本用法。

这边叫闹三栽多少检索方法

先是栽:用count函数来判断关键字是否出现,其短是力不从心稳定数据出现岗位,由于map的特性,一对一的投关系,就控制了count函数的回值就发些许单,要么是0,要么是1,出现的状况,当然是回到1了

亚种植:用find函数来恒定数据出现岗位,它回到的一个迭代器,当数码出现时,它回到数据所在位置的迭代器,如果map中没有假设找的数,它回到的迭代器等于end函数返回的迭代器,程序说明

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

       Map<int, string> mapStudent;

       mapStudent.insert(pair<int, string>(1, “student_one”));

       mapStudent.insert(pair<int, string>(2, “student_two”));

       mapStudent.insert(pair<int, string>(3, “student_three”));

       map<int, string>::iterator iter;

       iter = mapStudent.find(1);

if(iter != mapStudent.end())

{

       Cout<<”Find, the value is
”<<iter->second<<endl;

}

Else

{

       Cout<<”Do not Find”<<endl;

}

}

老三种:这个艺术用来判定数据是否出现,是展示笨了碰,但是,我打算以这边上课

Lower_bound函数C++用法,这个函数用来回到要物色关键字的下界(是一个迭代器)

Upper_bound函数用法,这个函数用来回到要寻找关键字之上界(是一个迭代器)

譬如说:map中已经插入了1,2,3,4之语,如果lower_bound(2)的话,返回的2,而upper-bound(2)的话,返回的就算是3

Equal_range函数返回一个pair,pair里面第一只变量是Lower_bound返回的迭代器,pair里面第二个迭代器是Upper_bound返回的迭代器,如果立即有限独迭代器相等的话,则印证map中莫出现这个第一字,程序说明

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

       Map<int, string> mapStudent;

       mapStudent[1] =  “student_one”;

       mapStudent[3] =  “student_three”;

       mapStudent[5] =  “student_five”;

       map<int, string>::iterator  iter;

iter = mapStudent.lower_bound(2);

{

       //返回的是下界3底迭代器

       Cout<<iter->second<<endl;

}

iter = mapStudent.lower_bound(3);

{

       //返回的凡下界3的迭代器

       Cout<<iter->second<<endl;

}

 

iter = mapStudent.upper_bound(2);

{

       //返回的是上界3的迭代器

       Cout<<iter->second<<endl;

}

iter = mapStudent.upper_bound(3);

{

       //返回的是上界5的迭代器

       Cout<<iter->second<<endl;

}

 

Pair<map<int, string>::iterator, map<int,
string>::iterator> mapPair;

mapPair = mapStudent.equal_range(2);

if(mapPair.first == mapPair.second)
       {

       cout<<”Do not Find”<<endl;

}

Else

{

Cout<<”Find”<<endl;
}

mapPair = mapStudent.equal_range(3);

if(mapPair.first == mapPair.second)
       {

       cout<<”Do not Find”<<endl;

}

Else

{

Cout<<”Find”<<endl;
}

}

6.       数据的清空与判空

清空map中的数额可以用clear()函数,判定map中是否生数据好为此empty()函数,它回到true则说明是空map

7.       数据的勾

此要为此到erase函数,它来三个重复载了之函数,下面在例子中详细说明她的用法

#include <map>

#include <string>

#include <iostream>

Using namespace std;

Int main()

{

       Map<int, string> mapStudent;

       mapStudent.insert(pair<int, string>(1, “student_one”));

       mapStudent.insert(pair<int, string>(2, “student_two”));

       mapStudent.insert(pair<int, string>(3, “student_three”));

 

//如果您只要以身作则输出效果,请捎以下的一样种植,你看来底效应会比较好

       //如果要去1,用迭代器删除

       map<int, string>::iterator iter;

       iter = mapStudent.find(1);

       mapStudent.erase(iter);

 

       //如果要删减1,用要字删除

       Int n = mapStudent.erase(1);//如果去了见面回去1,否则返回0

 

       //用迭代器,成片的去

       //一下代码把全map清空

       mapStudent.earse(mapStudent.begin(), mapStudent.end());

       //成片删除要注意的凡,也是STL的特色,删除区间是一个前闭后开的集

 

       //自个长遍历代码,打印输出吧

}

8.       其他部分函数用法

这里有swap,key_comp,value_comp,get_allocator等函数,感觉到这些函数在编程用之匪是过剩,略过不表,有趣味之话语可自个研究

9.       排序

这边要出口的凡某些于强深的用法了,排序问题,STL中默认是以小于哀号来排序的,以上代码在排序上是免存在其他问题之,因为地方的第一字是int型,它本身支持小于号运算,在有些出奇情形,比如要字是一个结构体,涉及到排序虽会并发问题,因为它没有小于号操作,insert等函数在编译的下死,下面为来些许个方式解决是题材

首先种:小于号重载,程序举例

#include <map>

#include <string>

Using namespace std;

Typedef struct tagStudentInfo

{

       Int      nID;

       String   strName;

}StudentInfo, *PStudentInfo;  //学生信息

 

Int main()

{

    int nSize;

       //用学生信息映射分数

       map<StudentInfo, int>mapStudent;

    map<StudentInfo, int>::iterator iter;

       StudentInfo studentInfo;

       studentInfo.nID = 1;

       studentInfo.strName = “student_one”;

       mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));

       studentInfo.nID = 2;

       studentInfo.strName = “student_two”;

mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));

for (iter=mapStudent.begin(); iter!=mapStudent.end(); iter++)

   
cout<<iter->first.nID<<endl<<iter->first.strName<<endl<<iter->second<<endl;

 

}

上述程序是无力回天编译通过之,只要重载小于号,就OK了,如下:

Typedef struct tagStudentInfo

{

       Int      nID;

       String   strName;

       Bool operator < (tagStudentInfo const& _A) const

       {

              //这个函数指定排序策略,按nID排序,如果nID相等的话,按strName排序

              If(nID < _A.nID)  return true;

              If(nID == _A.nID) return strName.compare(_A.strName)
< 0;

              Return false;

       }

}StudentInfo, *PStudentInfo;  //学生信息

亚种植:仿函数的使用,这个上结构体中莫一直的小于号重载,程序说明

#include <map>

#include <string>

Using namespace std;

Typedef struct tagStudentInfo

{

       Int      nID;

       String   strName;

}StudentInfo, *PStudentInfo;  //学生信息

 

Classs sort

{

       Public:

       Bool operator() (StudentInfo const &_A, StudentInfo const &_B)
const

       {

              If(_A.nID < _B.nID) return true;

              If(_A.nID == _B.nID) return
_A.strName.compare(_B.strName) < 0;

              Return false;

       }

};

 

Int main()

{

       //用学生信息映射分数

       Map<StudentInfo, int, sort>mapStudent;

       StudentInfo studentInfo;

       studentInfo.nID = 1;

       studentInfo.strName = “student_one”;

       mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));

       studentInfo.nID = 2;

       studentInfo.strName = “student_two”;

mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));

}

10.   另外

出于STL是一个合并之完好,map的不少于是法都和STL中其他的物了合在一起,比如当排序上,这里默认用底凡自愧不如号,即less<>,如果一旦起十分至稍微排序为,这里提到到之东西多,在这无法一一加以印证。

还要说明的凡,map中由于她里面有序,由红黑树保证,因此多函数执行的日复杂度都是log2N的,如果用map函数可以兑现的效用,而STL  Algorithm也足以成功该意义,建议就此map自带函数,效率高有。