Abseil Code Review · 54/79

absl::compare — three-way 비교

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

#three-way comparison이 푸는 문제

C++20 이전에는 비교 가능 타입이 최소 6개의 연산자를 정의해야 했다(==, !=, <, <=, >, >=). 매번 boilerplate.

1
// 회피 — 6개 연산자 수동
2
struct Point {
3
    int x, y;
4
    bool operator==(const Point& o) const { return x == o.x && y == o.y; }
5
    bool operator!=(const Point& o) const { return !(*this == o); }
6
    bool operator<(const Point& o) const  { return std::tie(x, y) < std::tie(o.x, o.y); }
7
    bool operator<=(const Point& o) const { return !(o < *this); }
8
    bool operator>(const Point& o) const  { return o < *this; }
9
    bool operator>=(const Point& o) const { return !(*this < o); }
10
};

C++20 operator<=>는 한 번에 처리한다.

1
// C++20
2
struct Point {
3
    int x, y;
4
    auto operator<=>(const Point&) const = default;
5
};

Abseil은 C++17 이하 환경에 세 가지 ordering 카테고리를 제공해서 spaceship-스러운 디자인을 가능하게 한다(단 spaceship 자체는 컴파일러 지원이 필요해 직접 polyfill하지 않는다).

1
#include "absl/types/compare.h"
2

3
absl::weak_ordering    wo = absl::weak_ordering::less;
4
absl::strong_ordering  so = absl::strong_ordering::equal;
5
absl::partial_ordering po = absl::partial_ordering::unordered;

#세 가지 ordering 카테고리

카테고리	의미	예
`strong_ordering`	동등 = 구별 불가	int, std::string
`weak_ordering`	동등 = 같은 동치 클래스	대소문자 무시 문자열
`partial_ordering`	일부는 비교 불가	float (NaN), 부분 순서 집합

strong ⊆ weak ⊆ partial 관계. strong은 weak으로, weak은 partial로 변환 가능.

#값 종류

각 카테고리는 가능한 값이 정해져 있다.

1
// strong_ordering: less, equal, greater
2
absl::strong_ordering::less;
3
absl::strong_ordering::equal;
4
absl::strong_ordering::greater;
5

6
// weak_ordering: less, equivalent, greater
7
absl::weak_ordering::less;
8
absl::weak_ordering::equivalent;
9
absl::weak_ordering::greater;
10

11
// partial_ordering: less, equivalent, greater, unordered
12
absl::partial_ordering::less;
13
absl::partial_ordering::equivalent;
14
absl::partial_ordering::greater;
15
absl::partial_ordering::unordered;   // NaN 같은 경우

#0과의 비교

<=> 결과는 0과 비교해 의미를 본다.

1
auto r = a <=> b;
2
if (r < 0)       std::cout << "less";
3
else if (r == 0) std::cout << "equal/equiv";
4
else             std::cout << "greater";

absl::strong_ordering/weak_ordering/partial_ordering도 동일 인터페이스.

1
absl::weak_ordering r = CompareCaseInsensitive("Hello", "hello");
2
if (r == 0) {
3
    // equivalent
4
}

#비교 함수의 권장 시그니처

라이브러리 helper를 만들 때 three-way가 효율적이다(< 한 번, == 한 번 두 번 부르는 대신 한 번).

1
// 회피 — 두 번 비교
2
template <typename T>
3
int Cmp(const T& a, const T& b) {
4
    if (a < b) return -1;
5
    if (b < a) return 1;
6
    return 0;
7
}
8

9
// Good — 한 번에 의미 추출
10
template <typename T>
11
absl::weak_ordering ThreeWay(const T& a, const T& b);

#호환성 — std::strong_ordering으로 변환

C++20 컴파일러에서는 absl::*_ordering이 std::*_ordering의 별칭이다(C++20 이상 빌드).

1
// C++20 빌드
2
static_assert(std::is_same_v<absl::strong_ordering, std::strong_ordering>);

따라서 다음과 같은 자연스러운 마이그레이션이 가능.

1
// before — C++17 코드
2
absl::strong_ordering Compare(const T&, const T&);
3

4
// after — C++20에서도 그대로 컴파일, std와 호환
5
absl::strong_ordering Compare(const T&, const T&);

#absl::compare가 spaceship을 구현하나?

직접 구현하지 않는다. operator<=>는 컴파일러 빌트인이라 폴리필이 불가능하다. Abseil이 제공하는 것은 결과 타입과 비교 helper뿐.

C++17 코드는 여전히 operator< 등 개별 연산자를 정의해야 한다. 다만 내부 비교 함수를 weak_ordering 반환으로 통일해 두면 C++20 마이그레이션 시 매끄럽다.

#작은 예시 — version comparison

1
struct Version {
2
    int major, minor, patch;
3
    std::string prerelease;   // 빈 문자열이 stable
4

5
    absl::weak_ordering CompareTo(const Version& o) const {
6
        // abseil은 public 3-way compare functor를 제공하지 않는다. 직접 만든다.
7
        auto cmp = [](const auto& a, const auto& b) -> absl::weak_ordering {
8
            if (a < b) return absl::weak_ordering::less;
9
            if (b < a) return absl::weak_ordering::greater;
10
            return absl::weak_ordering::equivalent;
11
        };
12
        if (auto r = cmp(major, o.major); r != 0) return r;
13
        if (auto r = cmp(minor, o.minor); r != 0) return r;
14
        if (auto r = cmp(patch, o.patch); r != 0) return r;
15

16
        // prerelease 있음 < prerelease 없음 (semver 규칙)
17
        if (prerelease.empty() != o.prerelease.empty()) {
18
            return prerelease.empty() ? absl::weak_ordering::greater
19
                                       : absl::weak_ordering::less;
20
        }
21
        return cmp(prerelease, o.prerelease);
22
    }
23

24
    bool operator<(const Version& o) const  { return CompareTo(o) < 0; }
25
    bool operator==(const Version& o) const { return CompareTo(o) == 0; }
26
    // 나머지 연산자는 < 와 ==에서 파생
27
};

#회피 패턴

1
// 회피 — 비교 함수가 bool 반환만
2
bool LessVersion(const Version& a, const Version& b);   // < 만 표현 가능
3

4
// Good — three-way
5
absl::weak_ordering CompareVersion(const Version& a, const Version& b);

1
// 회피 — float에 strong_ordering
2
absl::strong_ordering Cmp(float a, float b);   // NaN 처리 모호
3

4
// Good — partial_ordering
5
absl::partial_ordering Cmp(float a, float b);