Abseil Code Review · 56/79

Abseil AbslHashValue 분석

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

#std::hash의 불편

std::hash를 사용자 타입에 적용하려면 std namespace에 specialization 을 추가해야 한다.

1
// 회피 — std namespace 침범
2
namespace std {
3
template <>
4
struct hash<MyPoint> {
5
    size_t operator()(const MyPoint& p) const {
6
        return hash<int>{}(p.x) ^ hash<int>{}(p.y);   // 약한 해시
7
    }
8
};
9
}

문제 두 가지:

외부 namespace에 코드를 추가해야 함(어느 헤더에 둘지 골치).
int별 해시를 XOR로 섞는 직접 합성 은 충돌이 잦다.

Abseil은 멤버처럼 정의하는 friend 함수 를 통해 이 둘을 모두 해결한다.

friend 함수 → HashState chain의 흐름은 다음과 같다.

AbslHashValue friend 패턴

#AbslHashValue — friend ADL 기반

1
#include "absl/hash/hash.h"
2

3
struct MyPoint {
4
    int x, y;
5

6
    template <typename H>
7
    friend H AbslHashValue(H h, const MyPoint& p) {
8
        return H::combine(std::move(h), p.x, p.y);
9
    }
10
};
11

12
absl::flat_hash_set<MyPoint> set;
13
set.insert({1, 2});

핵심 패턴:

friend 함수로 클래스 안에 정의.
첫 인자가 HashState 템플릿(H).
H::combine(std::move(h), fields...)로 필드 chaining.
결과 H를 반환.

이름이 AbslHashValue로 고정되어 있고 ADL로 찾아진다. namespace를 침범하지 않는다.

#왜 friend인가

friend로 클래스 안에 두면:

클래스와 함께 정의·유지·삭제됨.
private 필드에 접근 가능.
헤더의 한 곳에 모여 검색·리뷰 쉬움.

1
class User {
2
public:
3
    User(std::string n, int a) : name_(std::move(n)), age_(a) {}
4

5
    template <typename H>
6
    friend H AbslHashValue(H h, const User& u) {
7
        return H::combine(std::move(h), u.name_, u.age_);   // private OK
8
    }
9

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

14
private:
15
    std::string name_;
16
    int age_;
17
};

해시 + 동등 비교가 함께 정의되므로 해시 컨테이너 호환성이 한 클래스에 박힌다.

#absl::Hash로 사용

직접 부르려면 absl::Hash<T>를 인스턴스화.

1
absl::Hash<MyPoint> hasher;
2
size_t h = hasher(MyPoint{1, 2});

absl::flat_hash_map, absl::flat_hash_set은 기본적으로 absl::Hash를 쓰므로 AbslHashValue 정의만 있으면 그대로 동작.

#std::hash와의 호환

Abseil은 std 컨테이너 호환을 위해 std::hash 특수화를 자동으로 만들지 않는다. std::unordered_map<MyPoint>를 쓰려면 여전히 std::hash 특수화가 필요하다.

1
// std 컨테이너 호환을 원한다면 함께 작성
2
namespace std {
3
template <>
4
struct hash<MyPoint> {
5
    size_t operator()(const MyPoint& p) const {
6
        return absl::Hash<MyPoint>{}(p);   // AbslHashValue로 위임
7
    }
8
};
9
}

std::hash가 absl::Hash를 부르도록 해 두면 해시 알고리즘이 한 곳에서 정의 된다.

#randomization — 같은 입력, 다른 출력

absl::Hash는 프로세스마다 다른 시드를 사용한다. 같은 객체도 프로세스를 재시작하면 해시값이 다르다.

1
// run 1
2
absl::Hash<int>{}(42) == 0x12345678'abcdef00ULL;
3

4
// run 2 (다른 프로세스)
5
absl::Hash<int>{}(42) == 0xfedcba98'76543210ULL;

이는 hash flooding DoS 방어 다. 공격자가 충돌하는 키를 미리 계산할 수 없다. 단점: 직렬화하면 다른 머신에서 의미 없음(분산 해싱에는 별도 algorithm 필요).

#회피 패턴

1
// 회피 — XOR로 직접 합성
2
template <typename H>
3
friend H AbslHashValue(H h, const MyPoint& p) {
4
    return H::combine(std::move(h),
5
                      std::hash<int>{}(p.x) ^ std::hash<int>{}(p.y));   // ❌ 약함
6
}
7

8
// Good — H::combine에 그대로 위임
9
template <typename H>
10
friend H AbslHashValue(H h, const MyPoint& p) {
11
    return H::combine(std::move(h), p.x, p.y);
12
}

1
// 회피 — std::hash 특수화만 (absl 컨테이너 사용 불가)
2
namespace std {
3
template <> struct hash<MyPoint> { ... };
4
}
5

6
// Good — AbslHashValue 우선, std 호환은 위임

1
// 회피 — operator== 빠짐
2
struct Bad {
3
    int x;
4
    template <typename H> friend H AbslHashValue(H h, const Bad& b) {
5
        return H::combine(std::move(h), b.x);
6
    }
7
    // ❌ operator==이 없으면 unordered 컨테이너에서 비교 실패
8
};

#작은 예시 — composite key

1
struct OrderKey {
2
    int64_t user_id;
3
    absl::Time when;
4
    std::string region;
5

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

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

16
absl::flat_hash_map<OrderKey, Order> orders;
17
orders[{123, absl::Now(), "us-east"}] = ...;