结构体作为map的key或放入set中，需要重载<运算符，如下：

typedef struct tagRoadKey

{

    int m_i32Type;

    int m_i32Scale;

    bool operator <(const tagRoadKey& other) const // 注意是const函数！！

    {

        if (m_i32Type != other.m_i32Type) // 类型按升序排序

        {

            return (m_i32Type < other.m_i32Type);

        }

        else // 如果类型相同，按比例尺升序排序

        {

            return (m_i32Scale < other.m_i32Scale);

        }

    }

} RoadKey;

也可以重载>运算符，示例如下：

#include <iostream>

#include <string>

#include <map>

using namespace std;

class Array

{

private:

    int m_i32Num1;

    int m_i32Num2;

public:

    Array(int i32Num1, int i32Num2);

    bool operator >(const Array& other) const;

};

Array::Array(int i32Num1, int i32Num2)

{

    m_i32Num1 = i32Num1;

    m_i32Num2 = i32Num2;

}

bool Array::operator >(const Array& other) const

{

    if (m_i32Num1 > other.m_i32Num1)

    {

        return true;

    }

    else

    {

        return false;

    }

}

// 此结构体作为map的value

struct TInfo

{

    int m_i32Num1;

    int m_i32Num2;

};

int main(int argc, char* argv[])

{

    map<Array, TInfo, greater<Array> > stMap;

    TInfo stInfo1 = { , };

    stMap.insert(pair<Array, TInfo>(Array(, ), stInfo1));

    TInfo stInfo2 = { , ,  };

    stMap.insert(pair<Array, TInfo>(Array(, ), stInfo2));

    TInfo stInfo3 = { , ,  };

    stMap.insert(pair<Array, TInfo>(Array(, ), stInfo3));

    for (map<Array, TInfo, greater<Array> >::iterator it = stMap.begin(); it != stMap.end(); ++it)

    {

        cout << it->second.m_i32Num1 << endl;

    }

    return ;

}

说明：

 map缺省是用less<Key>作为比较器，所以它要求作为Key的类要重载“<”操作符，没有重载“<”操作符，而是重载了“>”操作符就会报错。

反之，也可以显式地用greater<Key>作为比较器，此时就必要重载Key类中的“>”操作符了。

附：stl中map和set的声明，二者比较像，底层都是用红黑树实现的

template < class Key, class Compare = less<Key>,

           class Allocator = allocator<Key> > class set;

template < class Key, class T, class Compare = less<Key>,

           class Allocator = allocator<pair<const Key,T> > > class map;

template < class Key, class Compare = less<Key>,

           class Allocator = allocator<Key> > class multiset;

template < class Key, class T, class Compare = less<Key>,

           class Allocator = allocator<pair<const Key,T> > > class multimap;

从上面的声明可以看出，也可以定义一个函数对象Compare，声明map或set类型时传进入，如：

struct TTimeCompare

{

    bool operator ()(const CTimerEvent* po1, const CTimerEvent* po2)const

    {

        return (po1->m_oNextTick < po2->m_oNextTick);

    }

};

typedef multiset<CTimerEvent*, TTimeCompare> TEventSet;

struct ltstr // less than

{

    bool operator()(const char* s1, const char* s2) const

    {

        return strcmp(s1, s2) < ;

    }

};

set<const char*, ltstr> stSet; // set<Key, Compare, Alloc>

map<const char*, int, ltstr> stMap; // map<Key, Data, Compare, Alloc>

struct eqstr // equal

{

    bool operator()(const char* s1, const char* s2) const

    {

        return strcmp(s1, s2) == ;

    }

};

hash_map<const char*, int, hash<const char*>, eqstr> stHashMap;  // hash_map<Key, Data, HashFcn, EqualKey, Alloc>

// 自定义hash函数

namespace std

{

    template<>

    struct hash<KEY_TYPE>

    {

        size_t operator()(const KEY_TYPE& key) const

        {

            //return key.Hash();

        }

    };

}