Abseil Code Review · 70/79

Abseil algorithm container 확장 — c_sort·c_find_if·c_count_if

2026년 6월 13일 · Hawk · 3분 읽기

#한 줄 요약

absl::c_* 함수군은 STL algorithm의 container 받는 버전이다. std::sort(v.begin(), v.end()) 대신 absl::c_sort(v)로 적는다. C++20 std::ranges의 사전 버전에 해당하며 C++17 이하 빌드에서 동일한 효용을 제공한다.

#동기

STL algorithm은 iterator 두 개를 받는다. 의도는 “container 일부에도 적용할 수 있어야 한다”이지만 실제 사용의 95%는 container 전체다.

1
// 회피 — boilerplate 반복
2
std::sort(v.begin(), v.end());
3
auto it = std::find_if(v.begin(), v.end(), pred);
4
int n = std::count_if(v.begin(), v.end(), pred);
5
std::transform(v.begin(), v.end(), out.begin(), fn);

v.begin(), v.end()는 글자 수도 늘리고 타이포 위험도 만든다. v1.begin(), v2.end()처럼 서로 다른 container의 begin/end를 섞는 버그가 실제로 발생한다.

absl::c_*은 container 한 개를 받아 begin/end를 자동으로 풀어 준다.

1
// Good
2
absl::c_sort(v);
3
auto it = absl::c_find_if(v, pred);
4
int n = absl::c_count_if(v, pred);
5
absl::c_transform(v, out.begin(), fn);

#API와 사용법

대부분의 <algorithm> 함수에 c_ 접두사 버전이 있다.

1
#include "absl/algorithm/container.h"
2

3
// 정렬
4
absl::c_sort(v);
5
absl::c_sort(v, std::greater<>());
6
absl::c_stable_sort(v);
7

8
// 검색
9
auto it = absl::c_find(v, target);
10
auto it2 = absl::c_find_if(v, [](int x) { return x > 10; });
11
bool yes = absl::c_any_of(v, IsPositive);
12
bool all = absl::c_all_of(v, IsPositive);
13
bool none = absl::c_none_of(v, IsNegative);
14

15
// 카운트
16
int n = absl::c_count(v, target);
17
int m = absl::c_count_if(v, IsPositive);
18

19
// 변형
20
absl::c_transform(v, out.begin(), [](int x) { return x * 2; });
21
absl::c_copy(src, std::back_inserter(dst));
22
absl::c_copy_if(src, std::back_inserter(dst), pred);
23
absl::c_fill(v, 0);
24

25
// 집계
26
int sum = absl::c_accumulate(v, 0);
27
int prod = absl::c_accumulate(v, 1, std::multiplies<>());
28

29
// set 연산
30
std::vector<int> out;
31
absl::c_set_intersection(a, b, std::back_inserter(out));
32
absl::c_set_union(a, b, std::back_inserter(out));
33

34
// 순서·정렬 확인
35
bool sorted = absl::c_is_sorted(v);
36
absl::c_reverse(v);
37
absl::c_unique_copy(v, std::back_inserter(out));   // 인접 중복 제거 (in-place c_unique는 abseil이 의도적으로 생략)

#내부 구현

absl/algorithm/container.h의 구현은 얇은 어댑터다.

1
namespace absl {
2

3
template <typename C>
4
void c_sort(C& c) {
5
  std::sort(container_algorithm_internal::c_begin(c),
6
            container_algorithm_internal::c_end(c));
7
}
8

9
template <typename C, typename Compare>
10
void c_sort(C& c, Compare&& comp) {
11
  std::sort(container_algorithm_internal::c_begin(c),
12
            container_algorithm_internal::c_end(c),
13
            std::forward<Compare>(comp));
14
}
15

16
template <typename C, typename Pred>
17
typename container_algorithm_internal::ContainerIter<C> c_find_if(C& c, Pred&& pred) {
18
  return std::find_if(container_algorithm_internal::c_begin(c),
19
                      container_algorithm_internal::c_end(c),
20
                      std::forward<Pred>(pred));
21
}
22

23
}  // namespace absl

c_begin/c_end는 std::begin/std::end의 ADL-safe wrapper다. C-style array도 그대로 받는다.

1
int arr[5] = {3, 1, 4, 1, 5};
2
absl::c_sort(arr);   // OK — C 배열도 동작

오버헤드는 없다. inline 호출 한 번이 컴파일러에 의해 사라진다.

#std::ranges와의 비교

C++20 std::ranges는 동일한 컨셉을 표준으로 제공한다.

1
// C++20 std::ranges
2
std::ranges::sort(v);
3
auto it = std::ranges::find_if(v, pred);
4
int n = std::ranges::count_if(v, pred);
5

6
// abseil
7
absl::c_sort(v);
8
auto it = absl::c_find_if(v, pred);
9
int n = absl::c_count_if(v, pred);

항목	absl::c_*	std::ranges
C++ 표준	— (C++14+ 동작)	C++20
projection (`&Foo::id`)	×	O
sentinel(불일치 begin/end)	×	O
view·composition (`v \| filter`)	×	O
iterator concept	duck typing	엄격
컴파일 오류 메시지	평이	template + concept 폭발

absl::c_*은 C++17 이하에서 ranges의 가장 일반적인 사용 케이스를 메운다. C++20 빌드면 표준 ranges를 우선 검토하되, projection이나 view composition을 쓰지 않는다면 차이가 거의 없다. Google 내부 코드는 일관성 차원에서 absl::c_*을 유지한다.

#코드 리뷰 포인트

1. v.begin(), v.end() 보면 자동 치환 후보

1
// before
2
std::sort(v.begin(), v.end());
3
// after
4
absl::c_sort(v);

이 패턴은 거의 mechanical refactor다. C++20 ranges를 쓸 환경이면 그쪽으로 바로 가도 좋다.

2. iterator를 명시적으로 들고 다닐 때는 그대로 두자

1
auto mid = v.begin() + v.size() / 2;
2
std::sort(v.begin(), mid);  // 부분 정렬 — c_sort로 줄일 수 없다

c_*은 container 전체용이다. 일부분만 다루면 STL을 그대로 쓴다.

3. associative container 주의

1
absl::flat_hash_map<int, int> m;
2
absl::c_sort(m);  // 컴파일 에러 — hash map은 정렬 불가

c_sort/c_unique는 random-access iterator를 요구한다. 컴파일러가 잡아 주지만 에러 메시지가 길다.

4. projection 필요하면 ranges

1
struct User { int id; std::string name; };
2
std::vector<User> users;
3

4
// c_*에서는 lambda 필요
5
absl::c_sort(users, [](const User& a, const User& b) { return a.id < b.id; });
6

7
// ranges는 projection 한 줄
8
std::ranges::sort(users, {}, &User::id);

projection이 자주 등장하는 코드라면 ranges가 더 짧다.

#자주 보는 안티패턴

서로 다른 container 섞기

1
// 회피 — STL이라면 컴파일은 되지만 UB 가능
2
std::sort(v1.begin(), v2.end());

c_*은 container 한 개만 받으므로 이 실수가 원천 차단된다. 그래서 c_*을 선호하는 이유 중 하나다.

lambda 안에서 it++ 오용

1
// 회피 — for 루프를 algorithm으로 위장
2
absl::c_for_each(v, [&](int x) {
3
  if (x == target) { /* break를 흉내내려 시도 */ }
4
});

c_for_each는 break가 없다. early exit이 필요하면 c_any_of / c_find_if가 옳다.

c_sort 이후 binary_search 누락

1
absl::c_sort(v);
2
// 회피 — linear search
3
if (absl::c_find(v, x) != v.end()) { ... }
4

5
// Good — sorted vector면 binary
6
if (absl::c_binary_search(v, x)) { ... }