STL库的映射容器有两个，一个是map，另一个是multimap。

这两个容器具体的使用原则，主要的区别在于key的设定，map中的key值必须唯一，multimap中的key值可以重复。

正常的情况下，我们可以使用map进行映射操作，但是如果有多个不同种的对象，其中某些对象还有相关性，他们的相关性是一对多的，对于这种情况，我们需要使用multimap进行这种关系的映射操作。我们这种操作有个限定就是从A多映射到B中。看下面的代码：

#define CRTLEN 60

//////////////////////BEGIN STRUCTURE DEFINITION///////////////////
struct SDRPModKey {
    __int64 nOption_Param_Em_Addr;
    int     nVersion;
};

struct STSKey {
    __int64 nOption_Param_Em_Addr;
    int     nCopyTSID;
};

class SDRPModKeyComp 
{
public:
    bool operator() (const SDRPModKey& e1, const SDRPModKey& e2) const 
    {
        return (e1.nOption_Param_Em_Addr < e2.nOption_Param_Em_Addr)
            || (e1.nOption_Param_Em_Addr == e2.nOption_Param_Em_Addr && e1.nVersion < e2.nVersion);
    }
};

class STSKeyComp 
{
public:
    bool operator() (const STSKey& e1, const STSKey& e2) const 
    {
        return (e1.nOption_Param_Em_Addr < e2.nOption_Param_Em_Addr)
            || (e1.nOption_Param_Em_Addr == e2.nOption_Param_Em_Addr && e1.nCopyTSID < e2.nCopyTSID);
    }
};

struct SCopyRule {
    // ID
    __int64 nOption_Param_Em_Addr;
    int     nLinenumber;

    // Parameters
    int     nCreateNewNode;
    int     nBillOfSupply;
    int     nManufacturingProcess;
    int     nCo_Product;
    wchar_t PVT_CRT[CRTLEN];   // ex: 49;51;
    wchar_t SEL_CRT[CRTLEN];
    wchar_t RuleKey[LENGTH_CLE];
    wchar_t RuleDesc[LENGTH_LIB];

    SCopyRule()
    {
        memset(this, 0, sizeof(SCopyRule));
    }
};

struct SCopyDRPMod {
    // ID
    __int64 nOption_Param_Em_Addr;
    int     nVersion;
    int     nLinenumber;

    // Parameters   
    int     nVersionCheck;
    int     nPVTCheck;

    SCopyDRPMod()
    {
        memset(this, 0, sizeof(SCopyDRPMod));
    }
};

struct SCopyDRPModPrv {
    // ID
    __int64 nOption_Param_Em_Addr;
    int     nVersion;
    int     nLinenumber;
    
    // Parameters
    wchar_t PrvKey[LENGTH_CLE];

    SCopyDRPModPrv()
    {
        memset(this, 0, sizeof(SCopyDRPModPrv));
    }
};

struct SCopyTS {
    // ID
    __int64 nOption_Param_Em_Addr;
    int     nCopyTSID;
    int     nLinenumber;

    // Parameters
    int     nLineNumberTSID;
    int     nFromTS;
    int     nFromVersion;
    int     nToTS;
    int     nToVersion;
    int     nPVTCheck;
    wchar_t SelKey[LENGTH_CLE];
    wchar_t SelDesc[LENGTH_LIB];

    SCopyTS()
    {
        memset(this, 0, sizeof(SCopyTS));
    }
};

struct SCopyTSPrv {
    // ID
    __int64 nOption_Param_Em_Addr;
    int     nCopyTSID;
    int     nLinenumber;

    // Parameters
    wchar_t PrvKey[LENGTH_CLE];

    SCopyTSPrv()
    {
        memset(this, 0, sizeof(SCopyTSPrv));
    }
};
//////////////////////END STRUCTURE DEFINITION///////////////////

//////////////////////BEGIN INI DEFINITION///////////////////
struct SDupBosRuleLoadParameters {
    int     nType;
    __int64 nOption_Param_Em_Addr;

    SDupBosRuleLoadParameters() 
    {
        nOption_Param_Em_Addr = 0L;
        nType                 = 0;
    }
};
struct SDupBosRuleSaveParameters {
    int     nType;
    CString strUser;

    SDupBosRuleSaveParameters() 
    {
        nType = 0;
    }
};
//////////////////////END INI DEFINITION///////////////////

typedef std::shared_ptr<SCopyRule>      SCopyRuleSPtr;
typedef std::shared_ptr<SCopyDRPMod>    SCopyDRPModSPtr;
typedef std::shared_ptr<SCopyTS>        SCopyTSSPtr;
typedef std::shared_ptr<SCopyDRPModPrv> SCopyDRPModPrvSPtr;
typedef std::shared_ptr<SCopyTSPrv>     SCopyTSPrvSPtr;
struct SDALDuplicateBosRule
{
public:
    typedef std::multimap<UINT, UINT>::iterator IDTOID;
    typedef std::pair<IDTOID, IDTOID> MAPIDGROUP;   
public:
    // If you add new map, please clear the map in fucntion FreeMap();
    std::map<UINT, SCopyRuleSPtr>              mapToCopyRule;
    std::map<UINT, SCopyDRPModSPtr>            mapToCopyDRPMod;
    std::map<UINT, SCopyTSSPtr>                mapToCopyTS;
    std::map<UINT, SCopyDRPModPrvSPtr>         mapToCopyDRPModPrv;
    std::map<UINT, SCopyTSPrvSPtr>             mapToCopyTSPrv;
                                               
    std::multimap<UINT, UINT>                  mapRuleIDToDRPModID;
    std::multimap<UINT, UINT>                  mapRuleIDToTSID;
    std::multimap<UINT, UINT>                  mapDRPModIDToPrvID;
    std::multimap<UINT, UINT>                  mapTSIDToPrvID;
                                               
    std::map<INT64, UINT>                      mapParamAddrToRuleID;    
    std::map<SDRPModKey, UINT, SDRPModKeyComp> mapDRPModKeyToDRPModID;
    std::map<STSKey, UINT, STSKeyComp>         mapTSKeyToTSID;

public:
    SDALDuplicateBosRule::~SDALDuplicateBosRule() {  FreeMap(); }
    void FreeMap();
};

其中 map的使用和multimap的使用方法，这是一个使用范本，可以参考其中的使用方法。代码是我工作项目的代码。代码不可以运行的。