Abseil Code Review · 11/79

Abseil Memory utilities 분석

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

cpp abseil memory smart-pointer allocator base

한 줄 요약: absl::memory는 std::make_unique, allocator_traits 같은 표준 도구의 polyfill과 보완을 제공한다. 현대 C++(14+)에서는 대부분 std로 옮겨갔지만, allocator-aware 구현에 필요한 일부 helper는 여전히 가치가 있다.

#어떤 문제를 푸는가

C++11은 std::unique_ptr을 도입했지만 std::make_unique를 빠뜨렸다. C++14에서 추가됐다. Abseil은 C++11 시절부터 absl::make_unique를 제공해 사용자가 직접 new를 쓸 필요가 없게 했다.

이제 C++14 이상이 표준이므로 absl::make_unique는 사실상 std::make_unique의 alias다. 그러나 allocator 관련 helper, uninitialized memory 다루기, raw pointer wrapping 같은 부분은 std에 부족하다.

#absl::make_unique

1
template <typename T, typename... Args>
2
typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
3
make_unique(Args&&... args) {
4
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
5
}

C++14의 std::make_unique와 동등. 새 코드는 std를 쓰는 것이 권장된다.

1
// 권장
2
auto p = std::make_unique<MyClass>(arg1, arg2);
3

4
// C++11 호환이 필요한 코드에서만
5
auto p = absl::make_unique<MyClass>(arg1, arg2);

배열 버전도 제공.

1
template <typename T>
2
typename std::enable_if<std::is_array<T>::value && std::extent<T>::value == 0,
3
                       std::unique_ptr<T>>::type
4
make_unique(size_t n) {
5
    return std::unique_ptr<T>(new typename std::remove_extent<T>::type[n]());
6
}
7

8
// 사용
9
auto arr = absl::make_unique<int[]>(100);

#absl::WrapUnique

raw pointer를 unique_ptr로 감싸는 명시적 함수.

1
template <typename T>
2
std::unique_ptr<T> WrapUnique(T* ptr) {
3
    static_assert(!std::is_array<T>::value, "array types are unsupported");
4
    static_assert(std::is_object<T>::value, "non-object types are unsupported");
5
    return std::unique_ptr<T>(ptr);
6
}

왜 필요한가. std::unique_ptr<T>(p) 생성자는 explicit이지만, factory 함수에서 일관된 표현이 도움 된다.

1
// C 라이브러리 함수가 raw pointer 반환
2
extern Widget* CreateWidget();
3

4
// 안전한 wrapping
5
std::unique_ptr<Widget> w = absl::WrapUnique(CreateWidget());
6

7
// new와 함께 쓰는 경우 — make_unique를 못 쓸 때
8
class Foo {
9
private:
10
    Foo();  // private constructor
11
    friend std::unique_ptr<Foo> CreateFoo();
12
};
13

14
std::unique_ptr<Foo> CreateFoo() {
15
    // make_unique는 private constructor 호출 못 함
16
    return absl::WrapUnique(new Foo());
17
}

WrapUnique의 이점은 ownership transfer를 코드에서 명확히 드러내는 것. new 다음에 바로 WrapUnique를 호출하는 패턴은 “이 pointer가 unique_ptr에 들어간다”는 의도를 명시한다.

#absl::pointer_traits 등

과거 absl::pointer_traits가 있었으나 지금은 ABSL_DEPRECATE_AND_INLINE로 std::pointer_traits에 위임된다. 보완 도구는 거의 없고 대부분 std를 그대로 쓴다.

#allocator_traits 보완

Abseil의 컨테이너(flat_hash_map 등) 구현은 std::allocator_traits를 적극 활용한다. 일부 helper는 internal namespace에서만 노출되어 있다.

1
// 의사 코드 — Abseil 내부
2
namespace container_internal {
3

4
template <typename Alloc, typename T, typename... Args>
5
void Construct(Alloc* alloc, T* ptr, Args&&... args) {
6
    std::allocator_traits<Alloc>::construct(*alloc, ptr,
7
        std::forward<Args>(args)...);
8
}
9

10
template <typename Alloc, typename T>
11
void Destroy(Alloc* alloc, T* ptr) {
12
    std::allocator_traits<Alloc>::destroy(*alloc, ptr);
13
}
14

15
}  // namespace container_internal

이 helper들은 public API가 아니다. 사용자 코드가 직접 부르지 말 것. 컨테이너를 만들 때는 표준 std::allocator_traits를 직접 사용한다.

#absl::nullopt 등의 관련 utility

엄밀히는 type utility지만 memory와 함께 자주 쓰인다.

1
absl::optional<MyClass> opt;
2
opt = absl::nullopt;
3

4
absl::optional<MyClass> opt2 = absl::make_optional<MyClass>(arg1, arg2);

C++17 이상에서는 std로 옮긴다.

1
std::optional<MyClass> opt = std::nullopt;
2
auto opt2 = std::make_optional<MyClass>(arg1, arg2);

#absl::Cleanup — RAII helper

C++20의 std::scope_guard와 비슷한 역할. (Abseil이 먼저 만들었고 표준이 따라잡은 케이스)

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

3
void ProcessFile(const std::string& path) {
4
    FILE* f = fopen(path.c_str(), "r");
5
    if (!f) return;
6
    auto close = absl::MakeCleanup([f]() { fclose(f); });
7

8
    // 사용
9
    Read(f);
10
    // close가 scope 끝에서 자동 호출
11
}

명시적 destructor 없이 RAII를 추가할 수 있다. 짧은 함수 안에서 한두 개의 자원을 깔끔하게 처리하기 위한 도구. unique_ptr를 쓸 정도로 정형화되지 않은 자원에 적합.

#취소 가능한 cleanup

1
auto cleanup = absl::MakeCleanup([&] { Rollback(); });
2

3
if (CommitWasSuccessful()) {
4
    std::move(cleanup).Cancel();  // cleanup 비활성화
5
}
6
// 성공이면 Rollback() 안 호출

이 패턴은 “성공할 때만 cleanup을 건너뛰기” 즉 transactional 코드에서 유용하다.

#std::pmr과의 관계

C++17이 도입한 polymorphic allocator는 Abseil이 별도로 다루지 않는다. std::pmr::*를 그대로 사용한다. Abseil의 컨테이너는 std::pmr::polymorphic_allocator도 사용할 수 있다.

1
std::pmr::monotonic_buffer_resource pool;
2
absl::flat_hash_map<int, std::string,
3
    absl::Hash<int>,
4
    std::equal_to<int>,
5
    std::pmr::polymorphic_allocator<std::pair<const int, std::string>>>
6
    map{&pool};

#std와의 비교

Abseil	std	권장
`absl::make_unique`	`std::make_unique` (C++14)	std
`absl::WrapUnique`	(없음)	absl — factory에서 명시적 ownership
`absl::make_optional`	`std::make_optional` (C++17)	std
`absl::nullopt`	`std::nullopt` (C++17)	std
`absl::MakeCleanup`	`std::experimental::scope_exit` (TS)	absl — 표준화 안 됨

#코드 리뷰 포인트

1
// 회피 — make_unique 대신 new
2
auto p = std::unique_ptr<MyClass>(new MyClass(args));
3

4
// Good
5
auto p = std::make_unique<MyClass>(args);
6

7
// new가 꼭 필요할 때만 WrapUnique
8
auto p = absl::WrapUnique(new MyClass());  // private ctor 등 특수 상황

1
// 회피 — 수동 cleanup
2
FILE* f = fopen(path, "r");
3
if (!f) return;
4
// ... 여러 줄 ...
5
fclose(f);  // 중간에 return 있으면 누수
6

7
// Good
8
FILE* f = fopen(path, "r");
9
if (!f) return;
10
auto close = absl::MakeCleanup([f] { fclose(f); });
11
// ... return이 어디서든 close 자동 호출

1
// 회피 — absl::make_optional을 C++17 코드에서 사용
2
auto opt = absl::make_optional<MyClass>(args);
3

4
// Good
5
auto opt = std::make_optional<MyClass>(args);

#자주 보는 안티패턴

1
// 회피 — unique_ptr 대신 raw new/delete
2
MyClass* p = new MyClass();
3
// ... 여러 줄 ...
4
delete p;  // 예외 또는 early return 시 누수
5

6
// Good
7
auto p = std::make_unique<MyClass>();

1
// 회피 — Cleanup을 변수 이름 없이 사용
2
absl::MakeCleanup([f] { fclose(f); });
3
// 이 표현식의 결과는 임시 객체. 다음 줄에서 destructor 호출됨.
4
// 즉시 cleanup 실행.
5

6
// Good — 변수에 바인딩
7
auto close = absl::MakeCleanup([f] { fclose(f); });

1
// 회피 — WrapUnique를 make_unique 대신
2
auto p = absl::WrapUnique(new MyClass(args));
3
// 작동하지만 make_unique가 더 안전. exception-safe.
4

5
// Good
6
auto p = std::make_unique<MyClass>(args);