在C++中哈希原始字节

Question

我想写一个函数，它采用两种类型T和U，这样sizeof(T)+sizeof(U)<=8和uint64_t只需一个接一个地重新解释它们的字节。然而，这似乎并不奏效。我确信有一种更快、更优雅(更正确(的方法可以做到这一点，但我一无所知。任何提示都将不胜感激。

#include <cstdint>
#include <iostream>
#include <vector>
template <typename T, typename U>
constexpr auto hash8(T x, U y) {
static_assert(sizeof(T) + sizeof(U) <= 8);
uint64_t u = 0;
uint64_t v = 0;
auto px = (uint8_t*)&x;
auto py = (uint8_t*)&y;
for (auto i = 0; i < sizeof(T); ++i) {
u |= (uint64_t)px[i];
u <<= 8;
}
for (auto i = 0; i < sizeof(U); ++i) {
v |= (uint64_t)py[i];
v <<= 8;
}
return u << (sizeof(U) * 8) | v;
}
int main() {
std::cout << hash8(131, 0) << 'n';
std::cout << hash8(132, 0) << 'n';
std::cout << hash8(500, 0) << 'n';
}

Answer 1

由于缺乏详细信息，我无法帮助解决代码中的问题，但我可以提出一个可能更简单的解决方案。

首先，我建议添加一个检查参数对象是否具有唯一的对象表示。除非这一点得到满足，否则散列将毫无意义。

其次，std::memcpy可能会让这件事变得更简单：

template <typename T, typename U>
auto
hash8(T x, U y) noexcept {
static_assert(sizeof x + sizeof y <= sizeof(std::uint64_t));
static_assert(std::has_unique_object_representations_v<T>);
static_assert(std::has_unique_object_representations_v<U>);
std::uint64_t ret{};
auto ptr = reinterpret_cast<unsigned char*>(&ret);
std::memcpy(ptr, std::addressof(x), sizeof x);
ptr += sizeof x;
std::memcpy(ptr, std::addressof(y), sizeof y);
return ret;
}

接下来，我们可以将其推广到任意数量的参数(只要它们合适(和不同的返回类型：

template <typename R = std::uint64_t, typename... Args>
auto
hash(Args... args) noexcept {
static_assert((sizeof args + ...) <= sizeof(R));
static_assert((std::has_unique_object_representations_v<Args> && ...));
static_assert(std::has_unique_object_representations_v<R>);
R ret{};
auto ptr = reinterpret_cast<unsigned char*>(&ret);
(
(
std::memcpy(ptr, std::addressof(args), sizeof args),
ptr += sizeof args
), ...
);
return ret;
}

---

需要注意的是，这样的哈希在不同的系统中是不一样的，即使对象的大小匹配。

第页。S.将函数设为constexpr是没有意义的，因为您使用了在常量表达式中不允许的重新解释强制转换。

Answer 2

最简单的方法通常是执行memcpy:

#include <cstdint>
#include <cstring> // for memcpy
template <typename T, typename U>
auto hash8(T x, U y) {
static_assert(sizeof(T) + sizeof(U) <= 8);
uint64_t u = 0;
char* u_ptr = reinterpret_cast<char*>(&u);
std::memcpy(u_ptr, &x, sizeof x);
std::memcpy(u_ptr+sizeof x, &y, sizeof y);
return u;
}

如果size参数在编译时是已知的(并且相当小(，那么任何合适的编译器都会将memcpy调用内联到几个位操作。

如果您确实需要constexpr函数，可以尝试使用C++20中的std::bit_cast(如果任何一个输入参数的大小都不是1、2、4或8，则可能会很困难(。