C++ Internals: STL之Map

Sat, 19 Jun 2010 04:25:00 GMT

概述

Map是标�?strong>兌��式容�?/strong>�Q?em>associative container�Q�之一�Q�一个map是一个键值对序列�Q�即�Q�key ,value�Q�对。它提供��Z��key�?strong>快�?/strong>��索能力，在一个map中key值是唯一的。map提供双向�q�代器，��x��从前往后的�Q�iterator�Q�，也有从后往前的�Q�reverse_iterator�Q��?/p>

map要求能对key�q�行<操作�Q�且保持按key值递增有序�Q�因此map上的�q�代器也是递增有序的。如果对于元素�ƈ不需要保持有序，可以使用hash_map�?/p>

map中key值是唯一的，如果马匹中已存在一个键值对(�늧�,密码):("skynet",407574364)�Q�而我们还��x��入一个键值对("skynet",472687789)则会报错�Q?span style="color: #ff0000;">不是报错�Q�准��的说是�Q�返回插入不成功�Q?/span>�Q�。而我们又的确惌��样做�Q�即一个键对应多个��|��q�运的是multimap可是实现�q�个功能�?/p>

下面我们用实例来深入介绍map�?em>multimap�Q�主要内容如下：

1、例子引�?
2、map中的�c�d��定义
3、map中的�q�代器和键值对
4、map中的构造函��C��析构函数
5、map中的操作�Ҏ��
6、再议map的插入操�?
7、[]不仅插入
8、multimap
9、�ȝ��

1、例子引�?/strong>

有一个服务器manager�l�护着接入服务器的client信息�Q�包括clinetId、scanRate、socketAddr�{�等。我们定义一个结构体保存scanRate、socketAddr信息。如下：

typedef int clientId; typedef struct{ int scanRate; string socketAddr; }clientInfo;

我们用map保存�q�些信息�Q�clientId为键key�Q�clientInfo为倹{��这��h��们可以通过clientId快速检索到client的相关信息，我们可以�q�样定义�Q?/p>
map clientMap;

�q�样我们定义了一个clientMap�Q�如果我们要定义多个�q�样的map�Q�需要多�ơ写map 变量名。�ؓ了避免这��h��况，我们通常为map定义个别名，如：

typedef map clientEdp; clientEdp clientMap;

之后我们��可以像定义clientMap一样定义map对象�Q�这��L��好处�q�有�Q�如果我们需要修改map的定义，只需要在一处修改即可，避免修改不彻底造成的不一致现象�?/p>
我们�q�就完成了需要的map的定义，如果不定义或没有在它上面的操作的话，��像定义�c�而没有方法一��P��意义不大或毫无意义。幸�q�的是，STL提供了这些常用操作：排序�Q�注�Q�map是不能也不要排序的，因�ؓmap本��n已经排好序了�Q�、打印、提取子部分、移除元素、添加元素、查扑֯�象，��像数据库的增删�Ҏ��操作�Q�现在我们详�l�介�l�这些操作，�q��步引入hash_map�?em>multimap�?/p>
2、map中的�c�d��定义

兌��数组�Q?em>associative array�Q�是最有用的用户定义类型之一�Q�经常内�|�在语言中用于文本处理等。一个关联数�l�通常也称为map�Q�有时也�U�字典（dictionary�Q�，保存一对倹{��第一个值称为key、第二个�U�Cؓ映射值mapped-value�?/p>
标准map是定义在std命名�I�间中的一个模板，�q�表�C�Zؓ。它首先定义了一�l�标准类型名字：

template, class A=allocator> class std::map { public: //types typedef Key key_type; typedef T mapped_type; typedef pair value_type; typedef Cmp key_compare; typedef A allocator_type; typedef typename A::reference reference; typedef typename A::const_reference const_reference; typedef implementation_define1 iterator; typedef implementation_define2 const_iterator; typedef typename A::size_type size_type; typedef typename A::difference_type difference_type; typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; //... }

注意�Q�map的value_type是一�?key,value)对，映射值的被认为是mapped_type。因此，一个map是一个pair元素的序列。从const Key可以看出�Q�map中键key是不可修改的�?/p>

不得不提的是map定义中Cmp和A都是可选项。Cmp是定义在元素之间的比较方法，默认�?lt;操作�Q�A即allocator用来分配�?strong>释放map总键值对所需使用的内存，没有指定的话即默认��用的是STL提供的，也可以自定义allocator来管理内存的使用。多数情况，我们不指定这两个选项而��用默认��|��q�样我们定义map��像下面�q�样�Q?/p>

map clientMap;

Cmp和A都缺省�?通常�Q�实际的�q�代器是实现定义的，因�ؓmap很像使用了树的�Ş式，�q�些�q�代器通常提供树遍历的某种形式。逆向�q�代器是使用标准的reverse_iterator模板构造的�?/p>

3、map中的�q�代器和键值对

map提供惯常的返回�P代器的一�l�函敎ͼ�如下所�C�：

template,
class A=allocator>
class std::map
{
public:
//...
//iterators
iterator    begin();
const_iterator    begin()    const;
iterator    end();
const_iterator    end()    const;
reverse_iterator    rbegin();
const_reverse_iterator    rbegin()    const;
reverse_iterator    rend();
const_reverse_iterator    rend()    const;
//...
}

map上的�q�代器是pair元素序列上简单的�q�代。例如，我们可能需要打印出所有的客户端信息，像下面的�E�序�q�样。�ؓ了实现这个，我们首先向《例子引入》中定义的clientEdp中插入数据，然后打印出来�Q?/p>

#include
#include
#include
using namespace std;
typedef    int    clientId;
typedef struct{
int scanRate;
string socketAddr;
}clientInfo;
int main(int argc,char** argv)
{
typedef map clientEdp;
typedef map::const_iterator iterator;
clientEdp clients;
clientInfo client[100];
char str[10];
string strAddr("socket addr client ");
for(int i=0;i<100;i++)
{
client[i].scanRate=i+1;
//convert int to char*
itoa(i+1,str,10);
//concatenate strAddr and str
client[i].socketAddr=strAddr+str;
cout<first<second.scanRate<second.socketAddr<
一个map�q�代器以key升序方式表示元素�Q�因此客��L��信息以cliendId升序的方式输出。运行结果可以证明这一点，�q�行�l�果如下所�C�：
 
�?、程序运行结�?/p>
我们以first引用键值对的key�Q�以second引用mapped value�Q�且不用���key和mapped value是什么类型。其实pair在std的模板中是这样定义的�Q?/p>
template struct std::pair{
typedef    T1    first_type;
typedef    T2    second_type;
T1    first;
T2    second;
pair():first(T1()),second(T2()){}
pair(const T1& x,const T2& y):first(x),second(y){}
template
pair(const pair& p):first(p.first),second(p.second){}
}
即map中，key是键值对的第一个元素且mapped value是第二个元素。pair的定义可以在中找刎ͼ�pair提供了一个方法方便创建键值对�Q?/p>
template pair
std::make_pair(const T1& t1,const T2& t2)
{
return pair(t1,t2);
}
上面的例子中我们���q����C���q�个�Ҏ��来创�?clientId,clientInfo)对，�q�作为Insert()�Ҏ��的参数。每个pair默认初始化每个元素的��gؓ对应�c�d��的默认倹{�?/p>
4、map中的构造函��C��析构函数
map�c�L��常提供了构造函数和析构函数�Q�如下所�C�：
template,
class A=allocator>
class std::map
{
//...
//construct/copy/destroy
explicit map(const Cmp&=Cmp(),const A&=A());
templatemap(In first,In last,
const Com&=Cmp(),const A&=A());
map(const map&);
~map();
map& operator=(const map&);
//...
}
复制一个容器意味着为它的每个元素分配空��_���q�拷贝每个元素倹{��这样做是性能开销是很大的�Q�应该仅当需要的时候才�q�样做�?strong>因此�Q�map传的是引�?/strong>�?/p>
5、map中的操作�Ҏ��
前面我们已经说过�Q�如果map中仅定义了一些key、mapped value�c�d��的信息而没有操作方法，���如定义个仅有字�D늚��c�L��义不大甚��x��无意义。由此可见map中定义操作方法非帔R��要！前面的例子我们就用到了不���方法，如返回�P代器的方法begin()、end()�Q�键值对插入�Ҏ��insert()。下面我们对map中的操作�Ҏ��做个全面的介�l�：
template,
class A=allocator>
class std::map
{
//...
//map operations
//find element with key k
iterator find(const key_type& k);
const_iterator find(const key_type& k) const;
//find number of elements with key k
size_type count() const;
//find first element with key k
iterator lower_bound(const key_type& k);
const_iterator lower_bound(const key_type& k) const;
//find first element with key greater than k
iterator upper_bound(const key_type& k);
const_iterator upper_bound(const key_type& k) const;
//insert pair(key,value)
pairinsert(const value_type& val);
iterator insert(iterator pos,const value_type& val);
templatevoid insert(In first,In last);
//erase element
void erase(iterator pos);
size_type erase(const key_type& k);
void erase(iterator first,iterator last);
void clear();
//number os elements
size_type size() const;
//size of largest possible map
size_type max_size() const;
bool empty() const{return size()==0;}
void swap(map&);
//...
}
上面�q�些�Ҏ��基本都能��֐�思义�Q�PS.由此可见�Q�命名有多重要，我们�q�x��要养成好的命名习惯，当然注释也必不可���！�Q�。虽然已�l�非常清楚了了，但我�q�是惌���解一下以消除不惜要的误解和更好地应用�q�些�Ҏ���?/p>

    find(k)�Ҏ�����单地�q�回键��gؓk的元素的�q�代器；如果没有元素的键��gؓk�Q�则�q�回map的end()�q�代器。由于map是按键key升序排列�Q�所有查扄���复杂度只有O(logN)。因此，我们通常会这��L���q�个�Ҏ���Q?

    #include
    #include
    #include
    using namespace std;
    typedef    int    clientId;
    typedef struct{
    int scanRate;
    string socketAddr;
    }clientInfo;
    int main(int argc,char** argv)
    {
    typedef map clientEdp;
    typedef map::const_iterator iterator;
    clientEdp clients;
    clientInfo client[100];
    char* str=new char[10];
    string strAddr("socket addr client ");
    for(int i=0;i<100;i++)
    {
    client[i].scanRate=i+1;
    //convert int to char*
    itoa(i+1,str,10);
    //concatenate strAddr and str
    client[i].socketAddr=strAddr+str;
    clients.insert(
    make_pair(i+1,client[i]));
    }
    delete str;
        clientId id=10;
    iterator i=clients.find(id);
    if(i!=clients.end()){
    cout<<"clientId: "<
    }
    
    insert()�Ҏ�� 试图���一个（Key,T�Q�键值对加入map。因为键时唯一的，所以仅当map中不存在键��gؓk的键值对时插入才成功。该�Ҏ��的返回��gؓpair�Q�如果插入成功bool��gؓTRUE�Q�iterator指向插入map中后的键值对。如下代码： 

    #include
    #include
    #include
    using namespace std;
    typedef    int    clientId;
    typedef struct{
    int scanRate;
    string socketAddr;
    }clientInfo;
    int main(int argc,char** argv)
    {
    typedef map clientEdp;
    typedef map::const_iterator iterator;
    clientEdp clients;
    clientId id=110;
    clientInfo cltInfo;
    cltInfo.scanRate=10;
    cltInfo.socketAddr="110";
    pair p110(id,cltInfo);
    pair p=clients.insert(p110);
    if(p.second){
    cout<<"insert success!"<first<second.scanRate<second.socketAddr<
    

上面我们看出�Q�这里我们插入键值对是首先声明一个键值对pair p110(id,cltInfo); 然后再插入，�q�个我们之前make_pair�Ҏ��不一��P��make_pair�Ҏ��用的比较多�?/p>

    erase()�Ҏ��用法比较���单，比如像清除clientId�?10的键值对�Q�我们只需要对clients调用erase�Ҏ���Q?span style="color: #ff8040;">clients.erase(clients.find(110));或者我们想清除clientId�?�?0的键值对�Q�我们可以这栯���用erase()�Ҏ���Q?span style="color: #ff8040;">clients.erase(clients.finds(1),clients.find(10));���单吧�Q�别得意�Q�你�q�需要注意，如果find(k)�q�回的是end()�Q�这栯���用erase()�Ҏ��则是一个严重的错误�Q�会对map造成破坏操作�?

6、再议map的插入操�?/strong>

前面我们介绍了利用map的插入方法insert()�Q�声明键值对pair或make_pair生成键值对然后我们可以��L��的将键值对插入map中。其实map�q�提供了更方便的插入操作利用下标�Q�subscripting�Q�[]�Q�操作，如下�Q?/p>
clientInfo cltInfo;
cltInfo.scanRate=10;
cltInfo.socketAddr="110";
clients[110]=cltInfo;
�q�样我们���可以简单地���键值对插入到map中了。下标操作在map中式�q�样定义的：
template,
class A=allocator>
class std::map
{
//...
//access element with key k
mapped_type& operator[](const key_type& k);
//...
}
我们来分析一下应用[]操作�Q�插入键值对的过�E�：���查键k是否已经在map里。如果不�Q�就��d��上，以v作�ؓ它的对应倹{��如果k已经在map里，它的兌�����D��更新成v。这里首先，查找110不在map中则创徏一个键�?10的键值对�Q��ƈ���映�����D��为默认��|���q�里scanRate�?�Q�socketAddr为空�Q�然后将映射��D��为cltInfo�?如果110在map中已�l�存在的话，则只是更��C��110为键的映���倹{�?/p>
从上面的分析可知�Q�如果大量这��h��入数据，会严重媄响效率！如果你考虑效率问题�Q�请使用insert操作。insert�Ҏ���Q�节省了三次函数调用�Q�一个徏立��时的默认映射值的对象�Q�一个销毁那个��时的对象和一个对映射值的赋值操作�?/p>
Note1�Q?/strong>如果k已经存在map中，[]效率反而比insert的效率高�Q�而且更美观！如果能够兼顾�q�两者那岂不是很���妙�Q�其实我们重写map中的[]操作�Q�首先判断k是否已经在map中，如果没有则调用insert操作�Q�否则调用内�|�的[]操作。如下列代码�Q?/p>
//////////////////////////////////////////////
///@param MapType-map的类型参�?
///@param KeyArgType-键的�c�d��参数
///@param ValueArgtype-映射值的�c�d��参数
///@return �q�代器，指向键�ؓk的键值对
//////////////////////////////////////////////
template
typename MapType::iterator
efficientAddOrUpdate(MapType& m,
const KeyArgType& k,
const ValueArgtype& v)
{
typename MapType::iterator Ib =    m.lower_bound(k);
if(Ib != m.end()&&!(m.key_comp()(k,Ib->first))) {
//key已经存在于map中做更新操作
Ib->second = v;
return Ib;
}
else{
//key不存在map中做插入操作
typedef typename MapType::value_type MVT;
return m.insert(Ib, MVT(k, v));
}
}

Note2�Q?/strong>我们视乎�q�忽略了一点，如果映射值mapped value的类型没有默认��|��怎么办？�q�种情况请勿使用[]操作插入�?/p>
7、[]不仅插入

通过[]操作不仅仅是插入键值对�Q�我们也可以通过键key���索出映射值mapped value。而且我们利用[]操作可以��L��地统计信息，如有�q�样�q�样一些键值对�Q�book-name�Q�count�Q�对�Q?/p>
(book1,1)�?book2,2)�?book1,2)�?book3,1)�?book3,5)
我们计算每种book的数量��d��。我们可以这样做�Q�将它们��d��一个map�Q?/p>
#include
#include
#include
using namespace std;
int main(int argc,char** argv)
{
map bookMap;
string book;
int count;
int total=0;
while(cin>>book>>count)
bookMap[book]+=count;
map::iterator i;
for(i=bookMap.begin();i!=bookMap.end();i++)
{
total+=i->second;
cout<first<<'\t'<second<
�l�果如下所�C�：�Q�注意按住ctrl+z键结束输入）
 
�?、程序运行结�?/p>
8、multimap
前面介绍了map�Q�可以说已经非常清晰了。如果允许clientId重复的话�Q�map���无能�ؓ力了�Q�这时候就得multimap上场了！multimap允许键key重复�Q�即一个键对应多个映射倹{�?/strong>其实除此之外�Q�multimap跟map是很像的�Q�我们接下来在map的基���上介�l�multimap�?/p>
multimap在std中的定义跟map一样只是类名�ؓmultimap�Q�multimap几乎有map的所有方法和�c�d��定义�?/p>

    multimap不支持[]操作�Q�但map支持
    
    multimap的insert�Ҏ���q�回的是一个�P代器iterator�Q�没有bool��|��而map��|��iterator�Q�bool�Q�的元素�?
    
    对应equal_range()、方法：
    
    pair equal_range(const key_type& k);
    pair
    equal_range(const key_type& k) const;
    //find first element with key k
    iterator lower_bound(const key_type& k);
    const_iterator lower_bound(const key_type& k) const;
    //find first element with key greater than k
    iterator upper_bound(const key_type& k);
    const_iterator upper_bound(const key_type& k) const;
    
    虽然在map和multimap都有�Q�显然对multimap有更多的意义�Q�equal_range()�Ҏ���q�回一个键key对应的多个映���值的上界和下界的键值对的�P代器、lower_bound()�Ҏ���q�回键multimap中第一个箭为key的键值对�q�代器、upper_bound()�Ҏ���q�回比key大的�W�一个键值对�q�代器�?

假设我们惛_��出键为key的所有映�����|��我们可以�q�样做：
#include
#include
#include
using namespace std;
typedef int clientId;
typedef struct{
int scanRate;
string socketAddr;
}clientInfo;
int main(int argc,char** argv)
{
typedef multimap clientEdp;
typedef multimap::const_iterator iterator;
clientEdp clients;
clientInfo client[20];
char* str=new char[10];
string strAddr("socket addr client ");
for(int i=0;i<10;i++)
{
client[i].scanRate=i+1;
//convert int to char*
itoa(i+1,str,10);
//concatenate strAddr and str
client[i].socketAddr=strAddr+str;
clients.insert(
make_pair(10,client[i]));
}
for(int i=10;i<20;i++)
{
client[i].scanRate=i+1;
//convert int to char*
itoa(i+1,str,10);
//concatenate strAddr and str
client[i].socketAddr=strAddr+str;
clients.insert(
make_pair(i+1,client[i]));
}
delete str,strAddr;
    //find elements with key 10
iterator lb=clients.lower_bound(10);
iterator ub=clients.upper_bound(10);
for(iterator i=lb;i!=ub;i++)
{
cout<<"clientId:"<first<second.scanRate<second.socketAddr<
�Q�说明：实际上，一般是不允许clientId重复的，�q�里只是��Z��举例。）�q�样是不是感觉很丑呢�Q�事实上�Q�我们可以更���单的�q�样�Q?/p>
//find elements with key 10
pair p=clients.equal_range(10);
for(iterator i=p.first;i!=p.second;i++)
{
cout<<"clientId:"<first<second.scanRate<second.socketAddr<
�ȝ��
map是一�c�d��联式容器。它的特�Ҏ��增加和删除节点对�q�代器的影响很小�Q�除了那个操作节点，对其他的节点都没有什么媄响。对于�P代器来说�Q�可以修改实��|��而不能修改key�?
map的功能：

    自动建立Key �Q�value的对应。key 和value可以是�Q意你需要的�c�d���?
    
    �Ҏ��key值快速查找记录，查找的复杂度基本是Log(N)�?
    
    快速插入Key - Value 记录�?
    
    快速删除记�?
    
    �Ҏ��Key 修改value记录�?
    
    遍历所有记录�?

展望�Q�本文不知不觉写了不���字了，但仍未深入涉及到map定义的第3个和�W?个参敎ͼ�使用的都是默认倹{�?/p>
template, 
    class A=allocator>
感兴���者，��h��扄���兌���料or下面留言希望看到单独开���介�l�map�W?个和�W?个参数。您的支持，我的动力�Q�PS�Q�在此文的原因，在与公司做项目用��C��map�Ҏ���ȝ��出来与大家共享，不过在进行个人�ȝ���q�程中，隑օ�会有疏漏或不当之处，请不吝指出�?/p>
参考文献：
�?】《The C++ Programming Language (Special Edition)�?/p>
�?】《Effective STL�?/p>

吴秦�Q�Saylor�Q?/a> 2010-06-19 12:25 发表评论

久久国产66,久久国产手机看片,欧美日韩中文字幕

C++ Internals: STL之Map

概述

1、例子引�?/strong>

2、map中的�c�d��定义

3、map中的�q�代器和键值对

4、map中的构造函��C��析构函数

5、map中的操作�Ҏ��

6、再议map的插入操�?/strong>

7、[]不仅插入

8、multimap

�ȝ��

参考文献：