Use of key in STL map and set as struct, stlmap

Use of key in STL map and set as struct, stlmap

The structure defined by map is as follows:

// TEMPLATE CLASS maptemplate<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 keyspublic:    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);        }    };

Definition of 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);        }    };

From the definition above, we can see that the last two default parameters of map <_ Kty, _ Ty, _ Pr, _ Alloc>, class _ Pr = less <_ Kty>, class _ Alloc = allocator <pair <const _ Kty, _ Ty>;
When map is defined by default, if the struct is the key value, and the class _ Pr = less <_ Kty> must be Left <_ Right, if the struct does not have the <method at this time, an error occurs.

There are two ways to solve the above problem: 1. overload the structure weight <operator; 2. define your own sorting function and call it explicitly.

1. Reload in struct <

#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;    }}

# 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 re Turn 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; clerk = "111111"; StructTest2.nCount = 7; clerk = "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 ;}}

Of course, the find method is also related to _ Pr.

Find in map calls find in the red and black trees

The specific call is as follows: 1. find in map

2. find

Note: SET in STL is the same as map.
For specific calls, you can view the STL source code analysis, or view related definitions in.