absl::Cleanup — 함수 종료 시 실행 보장

1
// 회피 — 모든 return 분기에서 close 호출 반복
2
absl::Status Process(const char* path) {
3
  int fd = ::open(path, O_RDONLY);
4
  if (fd < 0) return absl::InternalError("open");
5

6
  Header h;
7
  if (!ReadHeader(fd, &h)) {
8
    ::close(fd);
9
    return absl::DataLossError("header");
10
  }
11

12
  if (!Validate(h)) {
13
    ::close(fd);
14
    return absl::InvalidArgumentError("header");
15
  }
16

17
  ::close(fd);
18
  return absl::OkStatus();
19
}

1
// Good
2
absl::Status Process(const char* path) {
3
  int fd = ::open(path, O_RDONLY);
4
  if (fd < 0) return absl::InternalError("open");
5
  auto closer = absl::MakeCleanup([fd] { ::close(fd); });
6

7
  Header h;
8
  if (!ReadHeader(fd, &h)) return absl::DataLossError("header");
9
  if (!Validate(h)) return absl::InvalidArgumentError("header");
10
  return absl::OkStatus();
11
}

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

3
// 기본 사용 — MakeCleanup factory
4
auto c = absl::MakeCleanup([&] { ::close(fd); });
5

6
// CTAD를 통한 더 짧은 형태 (C++17)
7
absl::Cleanup c = [&] { ::close(fd); };
8

9
// 명시 취소 — Invoke()는 호출되지 않음
10
std::move(c).Cancel();
11

12
// 명시 실행 — 즉시 호출 후 lambda 폐기
13
std::move(c).Invoke();

1
auto c = absl::MakeCleanup([] { LOG(INFO) << "exit"; });
2
c.Cancel();             // 컴파일 에러 — lvalue
3
std::move(c).Cancel();  // OK

1
namespace absl {
2

3
template <typename Callback>
4
class ABSL_MUST_USE_RESULT Cleanup {
5
 public:
6
  Cleanup(Callback callback)
7
      : storage_(std::move(callback), /*engaged=*/true) {}
8

9
  Cleanup(Cleanup&& other) = default;
10

11
  void Cancel() && {
12
    storage_.Disengage();
13
  }
14

15
  void Invoke() && {
16
    storage_.Invoke();
17
  }
18

19
  ~Cleanup() {
20
    storage_.InvokeIfEngaged();
21
  }
22

23
 private:
24
  cleanup_internal::Storage<Callback> storage_;
25
};
26

27
template <typename Callback>
28
Cleanup(Callback) -> Cleanup<std::decay_t<Callback>>;
29

30
template <typename... Args, typename Callback>
31
absl::Cleanup<Callback> MakeCleanup(Callback callback) {
32
  return absl::Cleanup<Callback>(std::move(callback));
33
}
34

35
}  // namespace absl

1
// folly
2
SCOPE_EXIT { ::close(fd); };
3

4
// abseil
5
absl::Cleanup _ = [&] { ::close(fd); };

1
// 회피 — 임시 객체가 곧바로 destruct → lambda 즉시 실행
2
absl::MakeCleanup([&] { ::close(fd); });
3

4
// Good — 변수에 묶어 스코프 끝까지 살린다
5
auto c = absl::MakeCleanup([&] { ::close(fd); });

1
absl::Cleanup c = [&]() noexcept { ::close(fd); };

1
// 회피 — local 변수 ref가 cleanup보다 먼저 죽을 수 있다
2
auto MakeLogger() {
3
  std::string name = "log";
4
  return absl::MakeCleanup([&] { LOG(INFO) << name; });  // dangling
5
}
6

7
// Good — by value
8
auto MakeLogger() {
9
  std::string name = "log";
10
  return absl::MakeCleanup([n = std::move(name)] { LOG(INFO) << n; });
11
}

1
// 회피 — 의미 모호
2
bool was_paused = scheduler.IsPaused();
3
scheduler.Pause();
4
absl::Cleanup _ = [&] { if (!was_paused) scheduler.Resume(); };

1
// Good
2
class ScopedPause {
3
 public:
4
  explicit ScopedPause(Scheduler* s) : s_(s), was_paused_(s->IsPaused()) {
5
    if (!was_paused_) s_->Pause();
6
  }
7
  ~ScopedPause() { if (!was_paused_) s_->Resume(); }
8
 private:
9
  Scheduler* s_;
10
  bool was_paused_;
11
};

1
absl::Cleanup _ = [&] {
2
  if (some_cond) return absl::InternalError("...");  // 컴파일 에러 또는 무시
3
};

1
auto a = absl::MakeCleanup([&] { ::close(fd); });
2
auto b = absl::MakeCleanup([&] { Flush(fd); });  // b가 먼저 호출됨 (LIFO)