Boost 1.59 编译错误

Question

After updating my files to boost_1.59.0 i get an ambyguous error. I can't understand what's wrong because in boost 1.43 all work's fine.

This is my boost declaration and my function.

    boost::unordered_map<VID, size_t>::iterator iterTargetMap = rSkillUseInfo.TargetVIDMap.find(TargetVID);

if (rSkillUseInfo.TargetVIDMap.end() != iterTargetMap)
    {
        size_t MaxAttackCountPerTarget = 1;

        switch (SkillID)
            {
            case SKILL_SAMYEON:
            case SKILL_CHARYUN:
                MaxAttackCountPerTarget = 3;
                break;
            }

        if (iterTargetMap->second >= MaxAttackCountPerTarget)
            {
                sys_log(0, "SkillHack: Too Many Hit count from SkillID(%u) count(%u)", SkillID, iterTargetMap->second);
                return false;
            }

        iterTargetMap->second++;
    }
else
    {
        rSkillUseInfo.TargetVIDMap.insert( std::make_pair(TargetVID, 1) );
    }

I also tried with auto in c++11

auto iterator iterTargetMap = rSkillUseInfo.TargetVIDMap.find(TargetVID);

Here is my error log gcc49 http://pastebin.com/p1KLqs9H I can't write here the error is too big.

I'am stucked on this error for 4 days. :(

Here is vid.h

class VID
{
public:
    VID() : m_id(0), m_crc(0)
    {
    }

    VID(DWORD id, DWORD crc)
    {
        m_id = id;
        m_crc = crc;
    }

    VID(const VID &rvid)
    {
        *this = rvid;
    }

    const VID & operator = (const VID & rhs)
    {
        m_id = rhs.m_id;
        m_crc = rhs.m_crc;
        return *this;
    }

    bool operator == (const VID & rhs) const
    {
        return (m_id == rhs.m_id) && (m_crc == rhs.m_crc);
    }

    bool operator != (const VID & rhs) const
    {
        return !(*this == rhs);
    }

    operator DWORD() const
    {
        return m_id;
    }

    void Reset()
    {
        m_id = 0, m_crc = 0;
    }

private:
    DWORD m_id;
    DWORD m_crc;
};

Answer 1

By looking at the error, it looks like you have to define a hash function for the type VID to be able to use it as a key in a map.

Standard hash functions are already defined in the STL for basic types, but you have to define for yourself a specific one for your domain types.

Usually, it's enough to do something like this:

namespace std {
    template<> struct hash<VID> {
        using argument_type = VID;
        using result_type = std::size_t;

        result_type operator()(argument_type const& vid) const {
            // what to put here depends on the type of VID
            // and how you want to create the hash
        }
    };
}

The difficulties are usually in understanding how to create the hash. In my experience, for user defined classes, I've ever used the standard specialization with some data members, the most significant ones.

In your case, as an example, you could cast the DWORD s to a couple of unsigned int s and use them to get the hash by using std::hash<unsigned int> (I'm assuming that that's the DWORD from the Windows API, that is a 32 bit unsigned integer as far as I remember).

As already said in the comments, see here for further details.