Abseil Code Review · 55/79

Abseil utility — apply·in_place

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

#utility 헤더가 모은 작은 도구들

absl/utility/utility.h는 std 미도착 시기에 필요하던 작은 헬퍼를 모은 곳이다. 대부분 C++17/20에서 std로 들어왔지만 코드 호환을 위해 유지된다.

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

3
// 1. apply — tuple 풀어서 함수 호출
4
auto sum = absl::apply([](int a, int b, int c) { return a + b + c; },
5
                       std::make_tuple(1, 2, 3));   // 6
6

7
// 2. in_place_t / in_place_index_t — emplace tag
8
absl::optional<std::vector<int>> v(absl::in_place, {1, 2, 3});
9

10
// 3. integer_sequence / make_index_sequence — variadic 헬퍼
11
template <typename... Ts>
12
void PrintAll(std::tuple<Ts...> t) {
13
    PrintImpl(t, absl::make_index_sequence<sizeof...(Ts)>{});
14
}
15

16
// 4. exchange — 값 swap 한 줄
17
T old = absl::exchange(slot, new_value);

#absl::apply — tuple 인자 풀기

1
auto f = [](int a, std::string b, double c) { /* ... */ };
2
auto args = std::make_tuple(1, std::string("x"), 3.14);
3

4
absl::apply(f, args);   // f(1, "x", 3.14)

C++17에 std::apply가 들어왔으므로 그 환경에서는 std 별칭. 일반화된 콜백 처리, decorator, mock framework 내부에서 자주 등장.

1
// 실용 예 — 호출 정보를 캡처해 나중에 실행
2
struct CallRecord {
3
    std::function<void(std::tuple<int, std::string>)> invoker;
4
    std::tuple<int, std::string> args;
5
};
6

7
void RecordAndReplay(CallRecord r) {
8
    absl::apply(r.invoker, r.args);
9
}

#in_place_t — 직접 생성

optional/variant/any의 in-place 생성 tag.

1
absl::optional<std::vector<int>> v(absl::in_place, 10, 0);
2
// vector<int>(10, 0) 직접 생성 — 임시 vector 생성 없음
3

4
absl::variant<std::string, int> x(absl::in_place_index<0>, "hello");
5
absl::variant<std::string, int> y(absl::in_place_type<int>, 42);
6

7
absl::any a(absl::in_place_type<std::vector<int>>, {1, 2, 3});

C++17의 std::in_place, std::in_place_type, std::in_place_index와 동일.

#integer_sequence — variadic 헬퍼

variadic template과 tuple 인덱싱을 함께 다룰 때.

1
template <typename Tup, std::size_t... I>
2
void PrintImpl(const Tup& t, absl::index_sequence<I...>) {
3
    ((std::cout << std::get<I>(t) << " "), ...);
4
}
5

6
template <typename... Ts>
7
void Print(const std::tuple<Ts...>& t) {
8
    PrintImpl(t, absl::make_index_sequence<sizeof...(Ts)>{});
9
}
10

11
Print(std::make_tuple(1, "hello", 3.14));   // 1 hello 3.14

C++14 std::make_index_sequence의 polyfill. C++17 fold expression((... , expr))과 결합해 variadic을 깔끔히 처리.

#absl::exchange — 한 줄 swap

1
class Resource {
2
public:
3
    Resource(Resource&& other) noexcept
4
        : handle_(absl::exchange(other.handle_, kInvalidHandle)) {}
5

6
    Resource& operator=(Resource&& other) noexcept {
7
        if (this != &other) {
8
            std::swap(handle_, other.handle_);
9
        }
10
        return *this;
11
    }
12
};

exchange(target, new_value)는 old value를 반환 하고 target에 new_value를 넣는다. move ctor의 표준 관용구.

#absl::launder

C++17 std::launder. union·placement-new·reinterpret_cast 후 aliasing 규칙을 컴파일러에게 알린다.

1
alignas(T) std::byte storage[sizeof(T)];
2
T* p = new (storage) T();
3
T* clean = absl::launder(p);   // strict aliasing safe

custom allocator, in-place storage 구현에서만 등장. 일반 코드는 거의 만나지 않는다.

#그 외 작은 helpers

1
// to_address — fancy pointer를 raw로
2
T* p = std::to_address(it);   // iterator → raw pointer (가능한 경우)
3

4
// move_if_noexcept — strong exception safety 보장
5
T moved = std::move_if_noexcept(x);

과거 Abseil이 제공하던 이 계열 polyfill은 C++17 이후 std로 흡수되면서 제거·ABSL_DEPRECATE_AND_INLINE로 std에 위임됐다. 지금은 std:: 버전을 그대로 쓴다.

#작은 예시 — Variadic logging helper

1
template <typename... Args>
2
void DebugLog(absl::string_view label, Args&&... args) {
3
    auto tup = std::forward_as_tuple(std::forward<Args>(args)...);
4

5
    auto format = [label](auto&&... xs) {
6
        return absl::StrCat(label, ": ", absl::AlphaNum(xs)..., "");
7
    };
8

9
    LOG(INFO) << absl::apply(format, tup);
10
}
11

12
DebugLog("counts", 1, 2, 3, "go");   // "counts: 1 2 3 go"

apply + forward_as_tuple 조합으로 가변 인자를 한 번에 forward.

#회피 패턴

1
// 회피 — boilerplate
2
template <typename Tup, std::size_t... I>
3
auto Call(F f, Tup t, std::index_sequence<I...>) {
4
    return f(std::get<I>(t)...);
5
}
6

7
// Good
8
auto r = absl::apply(f, t);

1
// 회피 — optional에 임시 객체 만들고 move
2
absl::optional<std::vector<int>> v;
3
v = std::vector<int>(10, 0);   // 임시 + move
4

5
// Good — in_place로 직접
6
absl::optional<std::vector<int>> v(absl::in_place, 10, 0);

#정리

absl::apply — tuple을 함수 인자로 풀어 호출. C++17 std::apply의 polyfill.
absl::in_place/in_place_type/in_place_index — optional/variant/any in-place 생성 tag.
absl::make_index_sequence + fold expression — variadic 처리.
absl::exchange — move ctor 한 줄 관용구.
대부분 std에 들어왔으므로 C++17 이상 빌드에서는 std 별칭.