absl::StatusOr<T> — 값 또는 에러

1
// 두 단계 패턴 — 어색
2
User user;
3
absl::Status s = GetUser(42, &user);
4
if (!s.ok()) return s;
5
// user 사용

1
absl::StatusOr<User> GetUser(int id);
2

3
// 호출
4
auto result = GetUser(42);
5
if (!result.ok()) {
6
    LOG(ERROR) << result.status();
7
    return;
8
}
9
User user = *result;  // 또는 std::move(*result)

1
#include "absl/status/statusor.h"
2

3
absl::StatusOr<int> ParseInt(absl::string_view s) {
4
    int v;
5
    if (!absl::SimpleAtoi(s, &v)) {
6
        return absl::InvalidArgumentError(
7
            absl::StrCat("not a number: ", s));
8
    }
9
    return v;
10
}
11

12
void Demo() {
13
    auto r = ParseInt("42");
14
    if (!r.ok()) {
15
        LOG(ERROR) << r.status();
16
        return;
17
    }
18
    int n = *r;
19
    LOG(INFO) << "parsed: " << n;
20
}

1
// 성공 — 값으로 암묵 변환
2
absl::StatusOr<int> ok = 42;
3

4
// 실패 — Status로 암묵 변환
5
absl::StatusOr<int> err = absl::InvalidArgumentError("...");
6

7
// 명시적
8
absl::StatusOr<int> x(42);
9
absl::StatusOr<int> y(absl::Status(absl::StatusCode::kNotFound, "..."));

1
absl::StatusOr<User> r = GetUser(42);
2

3
// 검사
4
bool ok = r.ok();
5
absl::Status s = r.status();
6
absl::StatusCode code = r.status().code();
7

8
// 값 접근
9
User u1 = *r;                          // dereference (unchecked)
10
User u2 = r.value();                   // ok이 아니면 LOG(FATAL) 또는 throw
11
User* p = &r.value();
12
User u3 = std::move(r).value();        // 효율적 이동
13
User u4 = *std::move(r);
14

15
// member access
16
r->member;
17
(*r).member;

1
// 의사 코드
2
template <typename T>
3
class StatusOr {
4
public:
5
    // ...
6
private:
7
    union {
8
        Status status_;
9
        T value_;
10
    };
11
    bool has_value_;
12
};

1
sizeof(absl::StatusOr<int>)         // sizeof(int) + sizeof(void*) + alignment
2
sizeof(absl::StatusOr<std::string>) // sizeof(std::string) + sizeof(void*) + alignment

1
absl::StatusOr<std::vector<int>> GetData();
2

3
void Process() {
4
    auto r = GetData();
5
    if (!r.ok()) return;
6

7
    // 값 이동 — vector를 복사하지 않음
8
    std::vector<int> v = std::move(r).value();
9

10
    // 또는
11
    std::vector<int> v2 = *std::move(r);
12
}

1
// 회피 — reference를 담은 StatusOr
2
absl::StatusOr<User&> GetUser(int id);
3
// reference의 lifetime 문제
4

5
// Good — pointer 또는 value
6
absl::StatusOr<User*> GetUser(int id);
7
absl::StatusOr<User> GetUserCopy(int id);

1
// 회피 — void에 StatusOr
2
absl::StatusOr<void> DoIt();  // 컴파일 에러
3
// void는 값이 없음. Status 단독으로.
4

5
// Good
6
absl::Status DoIt();

1
absl::StatusOr<Config> LoadConfig(const std::string& path);
2
absl::StatusOr<Server> CreateServer(const Config& c);
3
absl::Status RunServer(Server* s);
4

5
absl::Status BootUp(const std::string& path) {
6
    auto config = LoadConfig(path);
7
    if (!config.ok()) return config.status();
8

9
    auto server = CreateServer(*config);
10
    if (!server.ok()) return server.status();
11

12
    return RunServer(&*server);
13
}

1
// 회피 — value()로 직접 dereference, ok 확인 없음
2
User u = GetUser(42).value();
3
// ok이 아니면 LOG(FATAL) 또는 throw. 비정상 종료.
4

5
// Good
6
auto r = GetUser(42);
7
if (!r.ok()) {
8
    LOG(ERROR) << r.status();
9
    return;
10
}
11
User u = *r;

1
// 회피 — 큰 T를 값으로 반환 후 복사
2
absl::StatusOr<std::vector<HugeStruct>> GetData();
3
auto r = GetData();
4
auto data = r.value();  // 복사
5

6
// Good — 이동
7
auto data = std::move(r).value();

1
// 회피 — StatusOr<T*>와 Owner의 혼동
2
absl::StatusOr<User*> CreateUser();
3
// 호출자가 delete 해야 하는지 모름.
4

5
// Good — unique_ptr 사용
6
absl::StatusOr<std::unique_ptr<User>> CreateUser();

1
// 회피 — 항상 성공인데 StatusOr
2
absl::StatusOr<int> Identity(int x) {
3
    return x;
4
}
5
// 그냥 int 반환.
6

7
// Good
8
int Identity(int x) { return x; }

1
// 회피 — StatusOr를 out param으로
2
void GetUser(int id, absl::StatusOr<User>* out);
3
// StatusOr는 return value용.
4

5
// Good
6
absl::StatusOr<User> GetUser(int id);

1
// 회피 — Status로 충분한데 StatusOr<bool>
2
absl::StatusOr<bool> Exists(int id);
3
// NotFound가 false, OK가 true로 표현 가능.
4

5
// Good — bool 자체가 의미 있는 정보면 OK
6
absl::StatusOr<bool> WasModified(int id);  // 진짜 bool 결과

1
// 회피 — 함수 깊은 곳에서 StatusOr를 풀고 다시 묶음
2
absl::StatusOr<Config> Load(...) {
3
    auto r = ParseConfig();
4
    if (!r.ok()) return r.status();
5
    Config c = *r;
6
    // ...
7
    return c;
8
}
9
// 풀었다 묶는 비용. ASSIGN_OR_RETURN으로 단축 가능.
10

11
// Good — 다음 편 참조

1
// C++23
2
std::expected<int, std::string> ParseInt(std::string_view s);
3

4
// Abseil
5
absl::StatusOr<int> ParseInt(absl::string_view s);