Abseil Code Review · 58/79

Abseil Custom hashable 구현

2026년 6월 12일 · Hawk · 2분 읽기

cpp abseil hash custom user-type

Twitter LinkedIn

#표준 hashable과 보너스

Abseil의 absl::Hash는 다음 타입을 기본으로 hashable로 인식한다.

모든 정수·실수·포인터
bool, char, wchar_t 등 문자형
std::string, absl::string_view
std::pair, std::tuple (요소가 hashable)
std::vector, std::array, std::set, std::map 등 표준 컨테이너
absl::flat_hash_set, absl::node_hash_set (combine_unordered)
absl::optional, absl::variant
absl::Time, absl::Duration

이 위에 사용자 타입만 AbslHashValue를 추가하면 된다.

#패턴 1 — 단순 value class

1
struct UserId {
2
    int64_t value;
3

4
    template <typename H>
5
    friend H AbslHashValue(H h, const UserId& id) {
6
        return H::combine(std::move(h), id.value);
7
    }
8

9
    friend bool operator==(UserId a, UserId b) { return a.value == b.value; }
10
};
11

12
absl::flat_hash_map<UserId, User> users;
13
users[UserId{42}] = ...;

내부 타입(int64_t)이 hashable이므로 한 줄.

#패턴 2 — 다중 필드

1
struct CompositeKey {
2
    std::string region;
3
    int64_t user_id;
4
    absl::CivilDay date;
5

6
    template <typename H>
7
    friend H AbslHashValue(H h, const CompositeKey& k) {
8
        return H::combine(std::move(h), k.region, k.user_id, k.date);
9
    }
10

11
    friend bool operator==(const CompositeKey& a, const CompositeKey& b) {
12
        return a.region == b.region && a.user_id == b.user_id && a.date == b.date;
13
    }
14
};

CivilDay도 Abseil이 기본 hashable로 제공.

#패턴 3 — enum class

enum class는 기본 hashable이지만 intentional하게 friend 함수를 두면 가독성이 좋다.

1
enum class Region : int { kUS, kEU, kAP };
2

3
template <typename H>
4
H AbslHashValue(H h, Region r) {
5
    return H::combine(std::move(h), static_cast<int>(r));
6
}

absl::Hash는 enum class를 underlying type으로 자동 처리하므로 작성 불필요 하지만, namespace 안의 의도 표현용으로 쓸 수 있다.

#패턴 4 — bytes / raw data

이미지 hash, 바이너리 키 등 raw 바이트:

1
struct Bytes {
2
    std::vector<uint8_t> data;
3

4
    template <typename H>
5
    friend H AbslHashValue(H h, const Bytes& b) {
6
        return H::combine_contiguous(std::move(h), b.data.data(), b.data.size());
7
    }
8
};

combine_contiguous로 trivial 타입 N개를 바이트 묶음으로 처리. 일반 combine(h, vec)보다 빠르다.

#패턴 5 — set-like (순서 무관)

1
class TagSet {
2
public:
3
    absl::flat_hash_set<std::string> tags;
4

5
    template <typename H>
6
    friend H AbslHashValue(H h, const TagSet& t) {
7
        return H::combine_unordered(std::move(h), t.tags.begin(), t.tags.end());
8
    }
9

10
    friend bool operator==(const TagSet& a, const TagSet& b) {
11
        return a.tags == b.tags;
12
    }
13
};

combine_unordered가 순서를 흡수 — {"a", "b"} 와 {"b", "a"} 가 같은 해시.

#패턴 6 — 비공개 필드 (friend)

1
class Money {
2
public:
3
    Money(int64_t cents, std::string currency)
4
        : cents_(cents), currency_(std::move(currency)) {}
5

6
    template <typename H>
7
    friend H AbslHashValue(H h, const Money& m) {
8
        return H::combine(std::move(h), m.cents_, m.currency_);
9
    }
10

11
    friend bool operator==(const Money& a, const Money& b) {
12
        return a.cents_ == b.cents_ && a.currency_ == b.currency_;
13
    }
14

15
private:
16
    int64_t cents_;
17
    std::string currency_;
18
};

friend라 private 멤버 접근 가능. 외부 namespace 침범 없음.

#패턴 7 — std::hash 호환 추가

std 컨테이너도 함께 받으려면:

1
struct MyKey {
2
    int x, y;
3

4
    template <typename H>
5
    friend H AbslHashValue(H h, const MyKey& k) {
6
        return H::combine(std::move(h), k.x, k.y);
7
    }
8

9
    friend bool operator==(MyKey a, MyKey b) { return a.x == b.x && a.y == b.y; }
10
};
11

12
// std::unordered_map<MyKey, V> 사용을 위해
13
namespace std {
14
template <>
15
struct hash<MyKey> {
16
    size_t operator()(const MyKey& k) const noexcept {
17
        return absl::Hash<MyKey>{}(k);
18
    }
19
};
20
}

absl::Hash로 위임하므로 알고리즘은 한 곳에서만 정의된다.

#회피 패턴

1
// 회피 — 일부 필드만 hash + 다른 필드까지 ==
2
struct Bad {
3
    int id;
4
    std::string name;
5
    int version;   // hash에는 안 들어가지만 ==에는 들어감
6

7
    template <typename H>
8
    friend H AbslHashValue(H h, const Bad& b) {
9
        return H::combine(std::move(h), b.id, b.name);   // version 빠짐
10
    }
11

12
    friend bool operator==(const Bad& a, const Bad& b) {
13
        return a.id == b.id && a.name == b.name && a.version == b.version;
14
        // ❌ a == b 이지만 hash 다를 수 있음 — 해시 컨테이너 invariant 위반
15
    }
16
};

규칙: a == b ⇒ hash(a) == hash(b). 두 함수의 필드 집합은 동일 해야 한다. 차이가 나면 해시 컨테이너에서 조회 실패가 일어난다.

1
// 회피 — 부동소수 hash
2
struct Bad {
3
    double x;
4
    template <typename H>
5
    friend H AbslHashValue(H h, const Bad& b) {
6
        return H::combine(std::move(h), b.x);
7
        // ❌ NaN != NaN인데 같은 비트면 hash 같음 — operator==의 의미와 충돌
8
    }
9
};

부동소수를 해시 키로 쓰는 것 자체가 보통 설계 실수다. 필요하면 NaN 정규화 + 부동소수 비교 정책을 명시.

#큰 객체에 대한 해시 캐싱

해시 계산이 무거우면 캐싱 을 고려한다.

1
class HugeKey {
2
public:
3
    HugeKey(std::string s) : s_(std::move(s)), h_(absl::Hash<std::string>{}(s_)) {}
4

5
    template <typename H>
6
    friend H AbslHashValue(H h, const HugeKey& k) {
7
        return H::combine(std::move(h), k.h_);   // 미리 계산
8
    }
9

10
    friend bool operator==(const HugeKey& a, const HugeKey& b) {
11
        return a.h_ == b.h_ && a.s_ == b.s_;   // hash 같지 않으면 빠른 fail
12
    }
13

14
private:
15
    std::string s_;
16
    size_t h_;   // cached
17
};