std::unordered_map（提供自己的Hash函数和等价准则）

在使用容器std::unordered_map< key, value >时，当key是内置类型或者std::string时，容器都能正常使用，而且由于查找时间为O（1），在编程时，特别适合充当hash_table来使用。

如果key是自定义类型时，直接使用std::unordered_map，编译时会报错，错误信息为：”error C2338: The C++ Standard doesn’t provide a hash for this type.”大意是，C++标准库没有为该类型提供hash操作！因此，针对自定义类型，我们在使用std::unordered_map时必须提供自定义的Hash函数。

注：以下内容全部参考和引用自《C++标准库》（第二版）

提供自己的Hash函数

所有的hash table都需要一个hash函数，把你放进去的元素的value映射至某个相关的bucket（注：标准库的unordered_map，底层实现是基于hashtable的，其避免冲突的方法是使用开链（seperate chaining）法，这种做法是在每一个表格元素中维护一个list，每个表格元素称之为buket（桶），如下图（摘自《STL源码剖析》））。

它的目标是，两个相等的value总是导致相同的bucket索引，而不同的value理应导致不同的bucket索引。对于任何范围内的（被传入的）value，hash函数应该提供良好的hash value分布。

Hash函数必须是个函数，或function object，它接收一个元素类型下的value作为参数，并返回一个类型为std::size_t的value。因此，bucket的当前数量并未考虑。将其返回值映射至合法的bucket索引范围内，是由容器内部完成。因此，你的目标是提供一个函数，可以把不同的元素值均匀映射至区间[0, size_t)内。

下面示范的是如何提供你自己的hash函数：

#include <functional>

class Customer
{
    ...
};

class CustomerHash
{
public:
    std::size_t operator()(const Customer& c) const
    {
        return ...
    }
};

在这里，CustomerHash是一个function object，为class Customer定义出hash函数。

如果不愿意传递一个function object成为容器的一部分，你也可以传递一个hash函数作为构造函数实参。然而请注意，hash函数相应的template类型也必须对应设妥：

std::size_t customer_hash_func(const Customer& c)
{
    return ...
}

std::unordered_set<Customer, std::size_t(*)(const Customer&)> 
    custset(20, customer_hash_func);

在这里，customer_hash_func()被传递为构造函数第二个实参，其类型为”一个pointer，指向某函数，该函数接受一个Customer并返回一个std::size_t”，作为第二template实参。

如果没有给予特殊的hash函数，默认的hash函数是hash<>，这是< functional >提供的一个function object，可以对付常见类型：包括所有整数类型、所有浮点数类型、pointer、std::string，以及若干特殊类型。这些之外的类型，就必须提供你自己的hash函数。

提供一个好的hash函数，说起来容易做起来难。就像搭便车一样，可以使用默认的hash函数来完成自己的hash函数。一个天真（naive）的做法是，单纯把那些数据栏”由默认之hash函数产生”的所有hash value加起来。举个例子：

class CustomerHash
{
public:
    std::size_t operator()(const Customer& c) const
    {
        return  std::hash<std::string>()(c.fname) +
                    std::hash<std::string>()(c.lname) +
                    std::hash<long>()(c.no);
    }
};

这里，返回的hash value只不过是Customer的数据栏fname、lname和no的hash value总和。如果预定义的所有hash函数对这些数据栏的类型以及所给予的值都能运作良好，那么三个值的总和必然也在[0, size_t)范围内。根据一般溢出规则（common overflow rule），上述结果值应该也能够有良好的分布。

然而专家认为，这仍然是粗劣的hash函数。提供一个良好的hash函数可能是十分棘手的事，似乎不如想象中那么轻松。

一个较好的做法如下，使用由Boost提供的hash函数和一个便利的接口：

#include <functional>

template<typename T>
inline void hash_combine(std::size_t& seed, const T& val)
{
    seed ^= std::hash<T>()(val)+0x9e3779b9 + (seed << 6) + (seed >> 2);
}

template<typename T>
inline void hash_val(std::size_t& seed, const T& val)
{
    hash_combine(seed, val);
}

template<typename T, typename... Types>
inline void hash_val(std::size_t& seed, const T& val, const Types&... args)
{
    hash_combine(seed, val);
    hash_val(seed, args...);
}

template<typename... Types>
inline std::size_t hash_val(const Types& ...args)
{
    std::size_t seed = 0;
    hash_val(seed, args...);
    return seed;
}

这里实现出一个辅助函数hash_val()，使用variadic template（可变参数模板），允许调用时给予任意数量、任意类型的元素，然后逐一个别处理（计算）hash value。例如：

class CustomerHash
{
public:
    std::size_t operator()(const Customer& c) const
    {
        return  hash_val(c.fname, c.lname, c.no);
    }
};

在其内部，hash_combine()会被调用。若干实验证明，它是”一般性hash函数”的优秀候选。

提供自己的等价准则（Equivalence Criterion）

作为unordered容器类型的第三（set）或第四（map）template参数，可以传递等价准则（equivalence criterion），那应该是一个predicate（判别式），用以找出同一个bucket内的相等value。默认使用的是equal_to<>， 它以operator==进行比较。基于此，提供合法等价准则的最方便做法就是为自己的类型提供operator==（如果它没有预先被定义为成员函数或全局函数）。例如：

class Customer
{
    ...
};

bool operator==(const Customer& c1, const Customer& c2)
{
    ...
}

std::unordered_set<Customer, CustomerHash> custset;
std::unordered_map<Customer, std::string, CustomHash> custmap;

当然，也可以提供自己的等价准则，例如：

#include <functional>

class Customer
{
    ...
};

class CustomerEqual
{
public:
    bool operator()(const Customer& c1, const Customer&c2) const
    {
        return ...
    }
};

std::unordered_set<Customer, CustomerHash, CustomerEqual> custset;
std::unordered_map<Customer, std::string, CustomHash, CustomerEqual> custmap;

这里针对类型Customer定义了一个function object，必须在其中实现operator()使它能够比较两个元素（对map而言是两个key）并返回一个bool值指示他们是否相等。

只要value在当前的等价准则下被视为相等，他们也应该在当前的hash函数下产生相同的hash value。基于这个原因，一个unordered容器如果被实例化时带有一个非默认的等价准则，通常也需要一个非默认的hash函数。

提供自己的Hash函数和等价准则

下面的程序展示了如何为类型Customer定义及指定一个hash函数和一个等价准则。

#include <functional>

template<typename T>
inline void hash_combine(std::size_t& seed, const T& val)
{
    seed ^= std::hash<T>()(val)+0x9e3779b9 + (seed << 6) + (seed >> 2);
}

template<typename T>
inline void hash_val(std::size_t& seed, const T& val)
{
    hash_combine(seed, val);
}

template<typename T, typename... Types>
inline void hash_val(std::size_t& seed, const T& val, const Types&... args)
{
    hash_combine(seed, val);
    hash_val(seed, args...);
}

template<typename... Types>
inline std::size_t hash_val(const Types& ...args)
{
    std::size_t seed = 0;
    hash_val(seed, args...);
    return seed;
}

class Customer
{
public:
    Customer(const std::string& fn, const std::string& ln, long no)
        : fname(fn), lname(ln), no(no)
    {
    }

    friend std::ostream& operator<<(std::ostream& strm, const Customer& c)
    {
        return strm << "[" << c.fname << "," << c.lname << ","
            << c.no << "]";
    }

    friend class CustomerHash;
    friend class CustomerEqual;

private:
    std::string fname;
    std::string lname;
    long            no;
};

class CustomerHash
{
public:
    std::size_t operator()(const Customer& c) const
    {
        return  hash_val(c.fname, c.lname, c.no);
    }
};

class CustomerEqual
{
public:
    bool operator()(const Customer& c1, const Customer& c2) const
    {
        return c1.no == c2.no;
    }
};

int main()
{
    std::unordered_map<Customer, int, CustomerHash, CustomerEqual> custmap;

    custmap.insert(std::pair<Customer, int>(Customer("nico", "journalist", 42), 1));

    std::cout << custmap[Customer("nico", "journalist", 42)] << std::endl;

    return 0;
}

使用Lambda作为Hash函数和等价准则

使用lambda具体指定hash函数和/或等价准则，例如：

...

class Customer
{
public:
    Customer(const std::string& fn, const std::string& ln, long no)
        : fname(fn), lname(ln), no(no)
    {
    }

    std::string firstname() const
    {
        return fname;
    }

    std::string lastname() const
    {
        return lname;
    }

    long number() const
    {
        return no;
    }

    friend std::ostream& operator<<(std::ostream& strm, const Customer& c)
    {
        return strm << "[" << c.fname << "," << c.lname << ","
            << c.no << "]";
    }

private:
    std::string fname;
    std::string lname;
    long            no;
};

int main()
{
    auto hash = [](const Customer& c)
    {
        return  hash_val(c.firstname(), c.lastname(), c.number());
    };

    auto eq = [](const Customer& c1, const Customer& c2)
    {
        return c1.number() == c2.number();
    };

    std::unordered_map<Customer, int, decltype(hash) , decltype(eq)> custmap(10, hash, eq);

    custmap.insert(std::pair<Customer, int>(Customer("nico", "journalist", 42), 1));

    std::cout << custmap[Customer("nico", "journalist", 42)] << std::endl;

    return 0;
}

在VS2013中，以上代码会报错，错误信息为：”C3497: 无法构造 lambda 实例”，出现该错误的原因是->“lambda 的默认构造函数被隐式删除”,因此，在VS2013里无法使用Lambda函数作为Hash函数和等价准则。

修改办法如下，将Hash函数和等价准则作为普通函数，以函数指针的形式作为构造函数的一部分，具体如下：

...

std::size_t hash(const Customer& c)
{
    return  hash_val(c.firstname(), c.lastname(), c.number());
};

bool eq(const Customer& c1, const Customer& c2)
{
    return c1.number() == c2.number();
};

int main()
{
    std::unordered_map<Customer, int, decltype(&hash) , decltype(&eq)> custmap(10, hash, eq);

    custmap.insert(std::pair<Customer, int>(Customer("nico", "journalist", 42), 1));

    std::cout << custmap[Customer("nico", "journalist", 42)] << std::endl;
}

修改后的代码，可以正常运行。但有一个需要特别注意的地方，decltype(hash)与decltype(&hash)返回的类型是不一样的，取获取函数指针的方式为后者，这里我们是需要函数指针的，因此需要选择后者（decltype(&hash)），如果选择前者会导致运行错误。