Google 스타일의 Abseil 사용 패턴

1
// ❌ 리뷰어: "이건 완벽하지 않아서 거부합니다"
2
// ✅ 리뷰어: "이 변경이 코드베이스를 개선하나요? 그렇다면 승인합니다"

1
// ✅ 좋은 설계: 단일 책임, 명확한 인터페이스
2
class UserRepository {
3
public:
4
    absl::StatusOr<User> FindById(int64_t id);
5
    absl::Status Save(const User& user);
6
    absl::Status Delete(int64_t id);
7
};
8

9
// ❌ 나쁜 설계: 너무 많은 책임
10
class UserManager {
11
public:
12
    User* FindUser(int id);
13
    void SaveUser(User* u);
14
    void SendEmail(User* u, std::string msg);  // 왜 여기에?
15
    void GenerateReport();                      // 관련 없음
16
    void UpdateCache();                         // 구현 상세 노출
17
};

1
// 리뷰어는 엣지 케이스를 생각해야 함
2
absl::StatusOr<int> ParseInt(absl::string_view input) {
3
    // ❌ 엣지 케이스 누락
4
    return std::stoi(std::string(input));
5

6
    // ✅ 엣지 케이스 처리
7
    if (input.empty()) {
8
        return absl::InvalidArgumentError("Empty input");
9
    }
10
    // overflow 처리, 비숫자 문자 처리 등...
11
}

1
// ❌ 과도하게 복잡
2
template<typename T, typename Alloc = std::allocator<T>,
3
         typename = std::enable_if_t<std::is_trivially_copyable_v<T>>>
4
class OptimizedBuffer {
5
    // 300줄의 메타프로그래밍...
6
};
7

8
// ✅ 적절한 복잡성 (필요한 만큼만)
9
class Buffer {
10
public:
11
    explicit Buffer(size_t capacity);
12
    void Append(absl::string_view data);
13
    absl::string_view View() const;
14
private:
15
    std::vector<char> data_;
16
};

1
// ✅ 좋은 테스트: 명확하고, 실패 시 원인 파악 쉬움
2
TEST(UserRepositoryTest, FindById_ReturnsUser_WhenExists) {
3
    UserRepository repo;
4
    repo.Save(User{.id = 42, .name = "Alice"});
5

6
    auto result = repo.FindById(42);
7

8
    ASSERT_TRUE(result.ok());
9
    EXPECT_EQ(result->name, "Alice");
10
}
11

12
TEST(UserRepositoryTest, FindById_ReturnsNotFound_WhenMissing) {
13
    UserRepository repo;
14

15
    auto result = repo.FindById(999);
16

17
    EXPECT_EQ(result.status().code(), absl::StatusCode::kNotFound);
18
}
19

20
// ❌ 나쁜 테스트: 무엇을 테스트하는지 불명확
21
TEST(UserTest, Test1) {
22
    auto u = GetUser();
23
    EXPECT_TRUE(u != nullptr);  // 무슨 조건?
24
}

1
// ✅ 좋은 이름: 의도가 명확
2
absl::Duration connection_timeout = absl::Seconds(30);
3
int num_active_connections;
4
bool ShouldRetryRequest(const Request& req);
5

6
// ❌ 나쁜 이름: 모호하거나 약어
7
int n;           // 무엇의 개수?
8
absl::Duration t;  // 무슨 시간?
9
bool Check();    // 무엇을 체크?
10
int cnt;         // count를 줄일 이유 없음

1
// ✅ 좋은 주석: WHY를 설명
2
// 레거시 시스템과의 호환성을 위해 1-based 인덱스 사용
3
int index = position + 1;
4

5
// ✅ 좋은 주석: 복잡한 알고리즘 설명
6
// Knuth-Morris-Pratt 알고리즘 사용
7
// 시간 복잡도: O(n + m), n = text 길이, m = pattern 길이
8
int KmpSearch(absl::string_view text, absl::string_view pattern);
9

10
// ❌ 나쁜 주석: WHAT을 반복
11
// counter를 1 증가시킨다
12
++counter;
13

14
// ❌ 나쁜 주석: 오래된 정보
15
// TODO(john): 2019년에 수정 예정

1
// Google 스타일 요약
2
class MyClass {  // 클래스 이름: PascalCase
3
public:
4
    void PublicMethod();  // 메서드: PascalCase
5

6
private:
7
    int member_variable_;  // 멤버 변수: snake_case + 밑줄
8
};
9

10
void FreeFunction();  // 자유 함수: PascalCase
11
int local_variable;   // 지역 변수: snake_case
12
const int kConstant = 42;  // 상수: k + PascalCase
13

14
namespace my_namespace {  // 네임스페이스: snake_case
15
// ...
16
}

1
// 원본 코드
2
void process(std::vector<int>& data) {
3
    for (int i = 0; i < data.size(); i++) {
4
        if (data[i] < 0) data[i] = 0;
5
    }
6
}
7

8
// ❌ 나쁜 리뷰 코멘트
9
// "이 코드 별로임"
10

11
// ✅ 좋은 리뷰 코멘트
12
// "몇 가지 개선 제안:
13
// 1. 함수 이름이 모호합니다. `ClampNegativeToZero`는 어떨까요?
14
// 2. `int` 대신 `size_t`를 사용하면 signed/unsigned 경고를 피할 수 있습니다.
15
// 3. range-based for를 쓰면 더 읽기 쉽습니다:
16
//    for (int& value : data) { if (value < 0) value = 0; }
17
// Nit: const correctness - data를 수정하지 않는다면 const& 사용"

1
// Abseil은 API 안정성을 중시
2
// 리뷰 시 확인: 이 API가 장기적으로 유지 가능한가?
3

4
// ❌ 불안정한 API: 구현 상세 노출
5
class Cache {
6
public:
7
    std::unordered_map<K, V>& GetInternalMap();  // 구현 노출
8
};
9

10
// ✅ 안정적인 API: 추상화된 인터페이스
11
class Cache {
12
public:
13
    absl::optional<V> Get(const K& key);
14
    void Put(const K& key, V value);
15
    void Remove(const K& key);
16
};

1
// Abseil 코드는 성능을 중요시
2
// 리뷰 시 확인: 불필요한 복사, 할당이 있는가?
3

4
// ❌ 불필요한 복사
5
std::string GetName() { return name_; }  // 복사 발생
6

7
// ✅ 참조 반환
8
absl::string_view GetName() const { return name_; }
9

10
// ❌ 반복적인 할당
11
for (const auto& item : items) {
12
    result += item + ", ";  // 매번 재할당
13
}
14

15
// ✅ 한 번에 처리
16
result = absl::StrJoin(items, ", ");

1
// Abseil 방식: absl::Status 사용
2

3
// ❌ 예외 사용 (Google/Abseil은 예외 사용 안 함)
4
User GetUser(int id) {
5
    if (!exists(id)) throw std::runtime_error("Not found");
6
    return users_[id];
7
}
8

9
// ✅ absl::StatusOr 사용
10
absl::StatusOr<User> GetUser(int id) {
11
    if (!exists(id)) {
12
        return absl::NotFoundError(absl::StrCat("User ", id, " not found"));
13
    }
14
    return users_[id];
15
}

1
Add caching layer to UserRepository
2

3
UserRepository.FindById() 호출이 DB를 직접 접근하여
4
지연 시간이 높았습니다 (p99: 50ms).
5

6
이 CL은 LRU 캐시를 추가하여:
7
- 캐시 히트 시 <1ms 응답
8
- 예상 히트율: 80%+
9

10
벤치마크 결과:
11
- Before: p50=10ms, p99=50ms
12
- After: p50=1ms, p99=15ms