absl::function_ref와 any_invocable — 함수 객체 전달의 두 축

1
// 회피 1 — 헤더 의존 강제
2
template <typename Pred>
3
void ForEach(Pred p);
4

5
// 회피 2 — copy 가능 강제 + alloc
6
void ForEach(std::function<void(int)> p);

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

3
void ForEach(absl::FunctionRef<void(int)> visit);
4

5
ForEach([](int x) { LOG(INFO) << x; });
6
ForEach(std::function<void(int)>(SomeFreeFn));
7
ForEach(SomeFreeFn);

1
// absl/functional/function_ref.h (요약)
2
template <typename R, typename... Args>
3
class FunctionRef<R(Args...)> {
4
  using Invoker = R (*)(intptr_t, Args...);
5

6
  intptr_t ptr_;
7
  Invoker invoker_;
8

9
 public:
10
  template <typename F>
11
  FunctionRef(F&& f) noexcept {
12
    ptr_ = reinterpret_cast<intptr_t>(std::addressof(f));
13
    invoker_ = [](intptr_t p, Args... args) -> R {
14
      return (*reinterpret_cast<F*>(p))(std::forward<Args>(args)...);
15
    };
16
  }
17

18
  R operator()(Args... args) const {
19
    return invoker_(ptr_, std::forward<Args>(args)...);
20
  }
21
};

1
// 회피
2
class Worker {
3
  absl::FunctionRef<void()> cb_;  // 곧 dangling
4
};
5

6
// Good — 보관할 거면 AnyInvocable 또는 std::function
7
class Worker {
8
  absl::AnyInvocable<void()> cb_;
9
};

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

3
absl::AnyInvocable<void()> task = [up = std::make_unique<int>(42)] {
4
  LOG(INFO) << *up;
5
};
6

7
scheduler.Post(std::move(task));

1
absl::AnyInvocable<int() const>            f1;  // const-callable만
2
absl::AnyInvocable<int() &&>               f2;  // 한 번만 호출 (소비)
3
absl::AnyInvocable<int() noexcept>         f3;  // noexcept callable만
4
absl::AnyInvocable<int(int) const noexcept> f4;

1
// 무료 — SBO 적용
2
absl::AnyInvocable<void()> f = [] { ... };
3

4
// alloc — 캡처가 큼
5
absl::AnyInvocable<void()> g = [v = std::vector<int>(100)] { use(v); };

1
// 회피 — alloc + copy 강제
2
void Each(std::function<void(int)> visit);
3

4
// Good
5
void Each(absl::FunctionRef<void(int)> visit);

1
// 회피 — copy 강제 + 큰 SBO
2
class TaskQueue {
3
  std::vector<std::function<void()>> queue_;
4
};
5

6
// Good — move-only OK, 작은 SBO
7
class TaskQueue {
8
  std::vector<absl::AnyInvocable<void() &&>> queue_;
9
};

1
// 회피 — 모든 호출자가 헤더로
2
template <typename Pred>
3
inline void ForEachLine(Pred p);
4

5
// Good — .cc로 이동
6
void ForEachLine(absl::FunctionRef<void(absl::string_view)> p);

1
absl::FunctionRef<void()> Cache() {
2
  return [] { LOG(INFO) << "cached"; };  // dangling — lambda는 임시
3
}

1
class Worker {
2
  absl::FunctionRef<void()> cb_;
3
  void Run() { cb_(); }   // ❌ 거의 확실히 dangling
4
};

1
// 호출자는 std::function을 들고 있고
2
std::function<void()> f = ...;
3
SomeAPI(f);   // SomeAPI는 absl::FunctionRef<void()>
4

5
// 의도와 다르게 SomeAPI 내부에서 f를 저장하려 하면 망가짐

1
for (;;) {
2
  scheduler.Post(absl::AnyInvocable<void()>([v = std::vector<int>(1000)] {...}));
3
}