STL map、set中key为结构体的用法

下面是map定义的结构：

// TEMPLATE CLASS map
template<class _Kty,
    class _Ty,
    class _Pr = less<_Kty>,
    class _Alloc = allocator<pair<const _Kty, _Ty> > >
    class map
        : public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false> >
    {    // ordered red-black tree of {key, mapped} values, unique keys
public:
    typedef map<_Kty, _Ty, _Pr, _Alloc> _Myt;
    typedef _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false> > _Mybase;
    typedef _Kty key_type;
    typedef _Ty mapped_type;
    typedef _Ty referent_type;    // retained
    typedef _Pr key_compare;
    typedef typename _Mybase::value_compare value_compare;
    typedef typename _Mybase::allocator_type allocator_type;
    typedef typename _Mybase::size_type size_type;
    typedef typename _Mybase::difference_type difference_type;
    typedef typename _Mybase::pointer pointer;
    typedef typename _Mybase::const_pointer const_pointer;
    typedef typename _Mybase::reference reference;
    typedef typename _Mybase::const_reference const_reference;
    typedef typename _Mybase::iterator iterator;
    typedef typename _Mybase::const_iterator const_iterator;
    typedef typename _Mybase::reverse_iterator reverse_iterator;
    typedef typename _Mybase::const_reverse_iterator
        const_reverse_iterator;
    typedef typename _Mybase::value_type value_type;
 
    map()
        : _Mybase(key_compare(), allocator_type())
        {    // construct empty map from defaults
        }
 
    explicit map(const key_compare& _Pred)
        : _Mybase(_Pred, allocator_type())
        {    // construct empty map from comparator
        }
 
    map(const key_compare& _Pred, const allocator_type& _Al)
        : _Mybase(_Pred, _Al)
        {    // construct empty map from comparator and allocator
        }
 
    template<class _Iter>
        map(_Iter _First, _Iter _Last)
        : _Mybase(key_compare(), allocator_type())
        {    // construct map from [_First, _Last), defaults
        _DEBUG_RANGE(_First, _Last);
        for (; _First != _Last; ++_First)
            this->insert(*_First);
        }
 
    template<class _Iter>
        map(_Iter _First, _Iter _Last,
            const key_compare& _Pred)
        : _Mybase(_Pred, allocator_type())
        {    // construct map from [_First, _Last), comparator
        _DEBUG_RANGE(_First, _Last);
        for (; _First != _Last; ++_First)
            this->insert(*_First);
        }
 
    template<class _Iter>
        map(_Iter _First, _Iter _Last,
            const key_compare& _Pred, const allocator_type& _Al)
        : _Mybase(_Pred, _Al)
        {    // construct map from [_First, _Last), comparator, and allocator
        _DEBUG_RANGE(_First, _Last);
        for (; _First != _Last; ++_First)
            this->insert(*_First);
        }
 
 #if _HAS_STRICT_CONFORMANCE
    void erase(iterator _Where)
        {    // erase element at _Where
        _Mybase::erase(_Where);
        }
 
    size_type erase(const key_type& _Keyval)
        {    // erase and count all that match _Keyval
        return (_Mybase::erase(_Keyval));
        }
 
    void erase(iterator _First, iterator _Last)
        {    // erase [_First, _Last)
        _Mybase::erase(_First, _Last);
        }
 #endif /* _HAS_STRICT_CONFORMANCE */
 
    mapped_type& operator[](const key_type& _Keyval)
        {    // find element matching _Keyval or insert with default mapped
        iterator _Where = this->lower_bound(_Keyval);
        if (_Where == this->end()
            || this->comp(_Keyval, this->_Key(_Where._Mynode())))
            _Where = this->insert(_Where,
                value_type(_Keyval, mapped_type()));
        return ((*_Where).second);
        }
    };

less的定义

template<class _Ty>
    struct less
        : public binary_function<_Ty, _Ty, bool>
    {    // functor for operator<
    bool operator()(const _Ty& _Left, const _Ty& _Right) const
        {    // apply operator< to operands
        return (_Left < _Right);
        }
    };

从上面定义可以看出，map<_Kty, _Ty, _Pr, _Alloc>的后两个默认的参数，class _Pr = less<_Kty> , class _Alloc = allocator<pair<const _Kty, _Ty> > >；

而默认缺省定义map时，此时如果结构体为key值时，而此时class _Pr = less<_Kty>要进行_Left < _Right，而如果此时结构体没有<方法时，则会出错。

解决上面问题有两种方法：1.在结构体重重载<操作符；2.定义自己的排序函数，显式调用。

1.结构体中重载<

#include <iostream>
#include <string>
#include <map>
using namespace std;
struct StructTest
{
    string sTemp;
    int nCount;
    bool operator<(const StructTest& test) const
    {
        if (sTemp < test.sTemp)
        {
            return true;
        }
        else if (sTemp == test.sTemp)
        {
            if (nCount < test.nCount)
                return true;
            else
                return false;
        }
        else
        {
            return false;
        }
    }
};
void main()
{
    map<StructTest,string>mapTest;
    map<StructTest,string>::iterator mapTestiter;
    StructTest StructTest1,StructTest2,StructTest3;
    StructTest1.sTemp="111111";
    StructTest1.nCount=6;
    StructTest2.sTemp="111111";
    StructTest2.nCount=7;
    StructTest3.sTemp="000000";
    StructTest3.nCount=6;
    mapTest.insert(make_pair(StructTest1,"1"));
    mapTest.insert(make_pair(StructTest2,"2"));
    mapTest.insert(make_pair(StructTest3,"3"));
    for (mapTestiter=mapTest.begin();mapTestiter!=mapTest.end();mapTestiter++)
    {
        cout<<(mapTestiter->first).sTemp<<" "<<(mapTestiter->first).nCount<<" "<<mapTestiter->second<<endl;
    }
 
}

2.定义自己的排序函数，显式调用

#include <iostream>
#include <string>
#include <map>
using namespace std;
struct StructTest
{
    string sTemp;
    int nCount;
};
 
struct ptr_less : public binary_function<StructTest,StructTest,bool>
{
    bool operator()(const StructTest& test1, const StructTest& test2) const
    {
        if (test1.sTemp < test2.sTemp)
        {
            return true;
        }
        else if (test1.sTemp == test2.sTemp)
        {
            if (test1.nCount < test2.nCount)
                return true;
            else
                return false;
        }
        else
        {
            return false;
        }
    }
};  
 
void main()
{
    map<StructTest,string,ptr_less>mapTest;
    map<StructTest,string,ptr_less>::iterator mapTestiter;
    StructTest StructTest1,StructTest2,StructTest3;
    StructTest1.sTemp="111111";
    StructTest1.nCount=6;
    StructTest2.sTemp="111111";
    StructTest2.nCount=7;
    StructTest3.sTemp="000000";
    StructTest3.nCount=6;
    mapTest.insert(make_pair(StructTest1,"1"));
    mapTest.insert(make_pair(StructTest2,"2"));
    mapTest.insert(make_pair(StructTest3,"3"));
    for (mapTestiter=mapTest.begin();mapTestiter!=mapTest.end();mapTestiter++)
    {
        cout<<(mapTestiter->first).sTemp<<" "<<(mapTestiter->first).nCount<<" "<<mapTestiter->second<<endl;
    }
 
}

当然其中的find方法也与_Pr有关。

map中find调用红黑树的find

具体调用如下：1.map中的find

2.红黑树中find

注意：STL中的SET与map一样。

具体调用可以查看STL源码剖析、或者vs中查看相关定义