Abseil Code Review · 72/79

absl::bind_front와 Overload — 함수 객체 보조 도구

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

#한 줄 요약

absl::bind_front는 맨 앞 매개변수만 묶는 단순 binder다. std::bind의 placeholder 지옥과 implicit ref decay 문제를 피하고 lambda보다 짧다. absl::Overload는 std::variant visitor를 람다 여러 개로 한 줄에 적게 해 주는 helper다.

#동기

함수 객체 합성에는 세 가지 표준 방법이 있다.

1
struct Adder { int Add(int a, int b) { return a + b; } };
2
Adder ad;
3

4
// 1. std::bind — placeholder, 복잡
5
auto f1 = std::bind(&Adder::Add, &ad, 10, std::placeholders::_1);
6

7
// 2. lambda — 명시적이지만 길다
8
auto f2 = [&ad](int x) { return ad.Add(10, x); };
9

10
// 3. absl::bind_front — 깔끔
11
auto f3 = absl::bind_front(&Adder::Add, &ad, 10);

std::bind는 다음 문제로 EMC++ Item 34에서 회피 권장이다.

placeholder가 위치 기반이라 복잡.
인자가 implicit std::ref/value로 결정 — 직관 어긋남.
error 메시지가 template 폭증.

bind_front는 앞에서부터 순차 binding만 지원해 의미를 단순화한다. C++20에 std::bind_front가 들어왔고 Abseil 버전은 그 polyfill이다.

#bind_front — API와 사용법

1
#include "absl/functional/bind_front.h"
2

3
// 멤버 함수 + this
4
auto handler = absl::bind_front(&Worker::Run, &worker);
5
handler(arg1, arg2);  // == worker.Run(arg1, arg2)
6

7
// 일반 함수 + 앞 인자 일부
8
int Sub(int a, int b) { return a - b; }
9
auto sub10 = absl::bind_front(Sub, 10);
10
sub10(3);  // 7
11

12
// pointer to data member
13
struct P { int x; };
14
auto get_x = absl::bind_front(&P::x);
15
P p{42};
16
get_x(p);  // 42

std::bind와 달리 placeholder를 쓰지 않는다. 묶지 않은 인자는 그 자리 그대로 호출 시점에 전달된다.

#lambda보다 좋은 점

1
// lambda
2
auto f = [obj = std::move(obj)](Arg a) { return obj.Do(a); };
3

4
// bind_front
5
auto f = absl::bind_front(&Obj::Do, std::move(obj));

후자가 더 짧고 컴파일 시간도 약간 빠르다. 정적 분석기가 인자 타입을 자동 추론하기 좋다.

#내부 구현 (요약)

1
namespace absl {
2

3
template <typename F, typename... BoundArgs>
4
constexpr auto bind_front(F&& f, BoundArgs&&... args) {
5
  return functional_internal::bind_front_t<
6
      std::decay_t<F>, std::decay_t<BoundArgs>...>(
7
      std::forward<F>(f), std::forward<BoundArgs>(args)...);
8
}
9

10
// bind_front_t는 INVOKE(f, args..., CallArgs...) 형태로 호출
11
}

placeholder가 없으므로 bound args + call args가 자연스럽게 concatenate. invoke 시 std::invoke를 그대로 사용.

#bind_front vs std::bind 비교

항목	std::bind	absl::bind_front (C++20 표준)
placeholder	`_1`, `_2`, …	없음
인자 순서 변경	가능	불가 (앞부터만)
`std::ref` 자동 처리	× (사용자 명시)	× (사용자 명시)
nested bind 평탄화	O (헷갈림)	×
권장 (EMC++ Item 34)	회피	권장

#Overload — variant visitor 도우미

std::visit는 callable 하나가 모든 alternative를 처리해야 한다. 보통 lambda 여러 개를 묶기 위해 overload trick을 쓴다.

1
// C++17 overload trick
2
template <typename... Ts>
3
struct overload : Ts... { using Ts::operator()...; };
4
template <typename... Ts>
5
overload(Ts...) -> overload<Ts...>;
6

7
std::variant<int, std::string, double> v = "hi";
8
std::visit(overload{
9
    [](int i)               { LOG(INFO) << "int " << i; },
10
    [](const std::string& s){ LOG(INFO) << "str " << s; },
11
    [](double d)            { LOG(INFO) << "dbl " << d; },
12
}, v);

이 boilerplate를 Abseil이 제공한다.

1
#include "absl/functional/overload.h"
2

3
std::variant<int, std::string, double> v = "hi";
4
std::visit(absl::Overload{
5
    [](int i)               { LOG(INFO) << "int " << i; },
6
    [](const std::string& s){ LOG(INFO) << "str " << s; },
7
    [](double d)            { LOG(INFO) << "dbl " << d; },
8
}, v);

매번 trick struct를 직접 정의할 필요가 없다.

#내부 구현

1
namespace absl {
2

3
template <typename... T>
4
class Overload : public T... {
5
 public:
6
  explicit Overload(T... ts) : T(std::move(ts))... {}
7
  using T::operator()...;
8
};
9

10
template <typename... T>
11
Overload(T...) -> Overload<T...>;
12

13
}  // namespace absl

Ts...를 base로 다중 상속하고 using 선언으로 operator()를 한 layer에 모은다. CTAD로 호출 측에서 template 인자 명시가 필요 없다.

#핵심 활용 — exhaustive matching

1
using Event = std::variant<LoginEvent, ClickEvent, ErrorEvent>;
2

3
void Handle(const Event& e) {
4
  std::visit(absl::Overload{
5
      [](const LoginEvent& l) { ... },
6
      [](const ClickEvent& c) { ... },
7
      [](const ErrorEvent& e) { ... },
8
  }, e);
9
}

모든 alternative에 대응하는 lambda를 적지 않으면 컴파일 에러. 새 alternative가 추가될 때 모든 visitor가 깨지므로 컴파일러가 누락을 잡아 준다. switch + enum 패턴의 가장 큰 약점(누락)을 막는다.

#default fall-through

모든 case를 다 적기 싫을 때 generic lambda를 마지막에 둔다.

1
std::visit(absl::Overload{
2
    [](const LoginEvent& l) { /* 처리 */ },
3
    [](const auto&)         { /* 그 외 */ },
4
}, e);

단, exhaustive matching의 안전망이 사라진다는 점을 인지하고 쓴다.

#std / Folly와의 비교

항목	std::bind	absl::bind_front	std::bind_front (C++20)
표준	C++11	—	C++20
placeholder	O	×	×
권장	회피	권장	권장

항목	overload trick	absl::Overload	std::overload (제안)
표준	C++17	—	(검토 단계)
boilerplate	사용자 정의 필요	라이브러리 제공	—

folly에는 folly::partial이 유사한 역할을 한다. 인자 capture 방식 차이가 있어 직접 호환은 안 된다.

#코드 리뷰 포인트

1. std::bind 발견 → bind_front 또는 lambda

1
// 회피
2
auto h = std::bind(&Worker::Run, &w, std::placeholders::_1, 42);
3

4
// Good 1 — bind_front (앞부터 묶음)
5
auto h = absl::bind_front(&Worker::Run, &w);  // 두 번째 42는 풀어둠
6
h(arg, 42);
7

8
// Good 2 — lambda (가독성 최우선)
9
auto h = [&w](Arg a) { return w.Run(a, 42); };

std::bind는 C++20 이후 사실상 deprecated에 가깝다.

2. variant 분기 → switch보다 Overload

1
// 회피 — index() 분기
2
switch (v.index()) {
3
  case 0: HandleInt(std::get<0>(v)); break;
4
  case 1: HandleStr(std::get<1>(v)); break;
5
}
6

7
// Good — exhaustive 보장
8
std::visit(absl::Overload{
9
    [](int i)               { HandleInt(i); },
10
    [](const std::string& s){ HandleStr(s); },
11
}, v);

index() 분기는 새 alternative 추가 시 누락을 잡지 못한다.

3. bind_front + AnyInvocable 조합

1
absl::AnyInvocable<void(int)> cb =
2
    absl::bind_front(&Service::OnEvent, service);

bound state는 AnyInvocable 안에 통째로 들어간다. SBO 안에 들어가는 크기에 주의.

#자주 보는 안티패턴

bind_front로 placeholder 흉내

1
// 회피 — 의도와 다르게 동작
2
auto f = absl::bind_front(Sub, 10);   // f(x) → Sub(10, x)
3
auto g = absl::bind_front(Sub, _, 10); // ❌ placeholder 미지원

뒤 인자를 묶고 싶으면 lambda. absl::bind_back은 C++23 std::bind_back까지 표준에 없다.

Overload에 캡처 ref가 살아남지 못함

1
auto Visit() {
2
  std::string greeting = "hi";
3
  return absl::Overload{
4
      [&](int) { LOG(INFO) << greeting; },  // greeting dangling
5
      [&](auto) { LOG(INFO) << "other"; },
6
  };
7
}