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源码剖析》))。
std::unordered_map(提供自己的Hash函数和等价准则)_第1张图片
它的目标是,两个相等的value总是导致相同的bucket索引,而不同的value理应导致不同的bucket索引。对于任何范围内的(被传入的)value,hash函数应该提供良好的hash value分布。

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

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

#include 

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_setstd::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::string>()(c.fname) +
                    std::hash::string>()(c.lname) +
                    std::hash()(c.no);
    }
};

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

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

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

#include 

template<typename T>
inline void hash_combine(std::size_t& seed, const T& val)
{
    seed ^= std::hash()(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 custset;
std::unordered_mapstd::string, CustomHash> custmap;

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

#include 

class Customer
{
    ...
};

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

std::unordered_set custset;
std::unordered_mapstd::string, CustomHash, CustomerEqual> custmap;

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

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

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

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

#include 

template<typename T>
inline void hash_combine(std::size_t& seed, const T& val)
{
    seed ^= std::hash()(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_mapint, CustomerHash, CustomerEqual> custmap;

    custmap.insert(std::pairint>(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_mapint, decltype(hash) , decltype(eq)> custmap(10, hash, eq);

    custmap.insert(std::pairint>(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_mapint, decltype(&hash) , decltype(&eq)> custmap(10, hash, eq);

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

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

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

你可能感兴趣的:(c++)