Abseil 자주 보는 anti-pattern

1
// 회피 — 임시 객체의 데이터 view
2
absl::string_view Bad() {
3
    return std::string("hello");   // ❌ 임시 std::string 즉시 소멸
4
}
5

6
absl::string_view sv = absl::StrCat("a", "b", "c");   // ❌ StrCat 결과 즉시 소멸
7

8
// Good
9
std::string s = absl::StrCat("a", "b", "c");
10
absl::string_view sv = s;   // s 살아 있는 동안만 사용

1
// 회피 — 멤버 변수로 저장
2
class Bad {
3
public:
4
    explicit Bad(absl::string_view s) : s_(s) {}   // ❌ s_가 dangle 가능
5
private:
6
    absl::string_view s_;
7
};
8

9
// Good
10
class Good {
11
public:
12
    explicit Good(absl::string_view s) : s_(s) {}
13
private:
14
    std::string s_;   // 복사 소유
15
};

1
// 회피
2
class Bad {
3
public:
4
    void Add(int x) { data_.push_back(x); }   // ❌ lock 없이 수정
5
private:
6
    absl::Mutex mu_;
7
    std::vector<int> data_;   // ❌ GUARDED_BY 없음
8
};
9

10
// Good
11
class Good {
12
public:
13
    void Add(int x) ABSL_LOCKS_EXCLUDED(mu_) {
14
        absl::MutexLock lock(&mu_);
15
        data_.push_back(x);
16
    }
17
private:
18
    absl::Mutex mu_;
19
    std::vector<int> data_ ABSL_GUARDED_BY(mu_);
20
};

1
// 회피
2
absl::Status DoWork() { /* ... */ }
3

4
void Caller() {
5
    DoWork();   // ❌ status 무시 — 컴파일러 경고는 나지만 코드 지나감
6
}
7

8
// 회피 — StatusOr value() 무방비
9
absl::StatusOr<int> Compute();
10
int v = Compute().value();   // ❌ 실패 시 throw
11

12
// Good — RETURN_IF_ERROR / ASSIGN_OR_RETURN 패턴
13
absl::Status Caller() {
14
    RETURN_IF_ERROR(DoWork());
15
    ASSIGN_OR_RETURN(int v, Compute());
16
    use(v);
17
    return absl::OkStatus();
18
}

1
// 회피
2
struct Bad {
3
    int id;
4
    std::string name;
5
    int version;
6

7
    template <typename H>
8
    friend H AbslHashValue(H h, const Bad& b) {
9
        return H::combine(std::move(h), b.id);   // id만
10
    }
11

12
    friend bool operator==(const Bad& a, const Bad& b) {
13
        return a.id == b.id && a.name == b.name;   // id + name
14
    }
15
};
16
// ❌ a == b 인데 hash 다름 가능 (절대 안 됨) — 또는 그 반대

1
// 회피
2
absl::flat_hash_map<int, std::vector<int>*> m;
3
auto* v = m[42];   // 새 슬롯 — null pointer
4
v->push_back(1);   // ❌ UB
5

6
// Good — node_hash_map 또는 value 보유
7
absl::flat_hash_map<int, std::vector<int>> m;
8
m[42].push_back(1);   // 자동 생성
9

10
// 또는 명시 insert
11
auto [it, inserted] = m.try_emplace(42);
12
it->second.push_back(1);

1
// 회피 — 단위 모호
2
void Wait(int seconds);
3
Wait(5);   // ms? s?
4

5
// Good
6
void Wait(absl::Duration d);
7
Wait(absl::Seconds(5));

1
// 회피 — Duration → int 추출 후 다시 만들기
2
int ms = static_cast<int>(absl::ToDoubleMilliseconds(d));
3
absl::Duration restored = absl::Milliseconds(ms);   // 정밀도 손실
4

5
// Good — Duration 그대로 전달
6
absl::Duration restored = d;

1
// 회피 — 로그 출력 검증을 stderr capture로
2
TEST(BadLog, Warning) {
3
    // stderr 캡처 + 문자열 매칭 ... ❌ 환경 의존, flaky
4
}
5

6
// Good — ScopedMockLog
7
TEST(GoodLog, Warning) {
8
    absl::ScopedMockLog log;
9
    EXPECT_CALL(log, Log(absl::LogSeverity::kWarning, _, HasSubstr("slow")));
10
    log.StartCapturingLogs();
11
    DoSlow();
12
}

1
// 회피
2
int Pick() {
3
    absl::BitGen bg;   // ❌ 매번 OS entropy 시드 — 비싸고 thread 충돌
4
    return absl::Uniform(bg, 0, 100);
5
}
6

7
// Good — thread_local
8
thread_local absl::BitGen tls_bg;
9
int Pick() { return absl::Uniform(tls_bg, 0, 100); }

1
// 회피
2
const bool verbose = absl::GetFlag(FLAGS_verbose);   // 캡처
3
absl::SetFlag(&FLAGS_verbose, true);
4
if (verbose) { ... }   // ❌ 여전히 이전 값
5

6
// Good — 런타임 변경 감지 필요하면 매번 GetFlag
7
if (absl::GetFlag(FLAGS_verbose)) { ... }

1
// 회피
2
absl::variant<int, std::string> v = "hello";
3
int x = absl::get<int>(v);   // ❌ throw absl::bad_variant_access
4

5
// Good
6
if (auto* p = absl::get_if<int>(&v)) {
7
    use(*p);
8
}

1
// 회피
2
std::string s = absl::FormatTime("%H:%M:%S", t, absl::LocalTimeZone());
3
// ❌ 호스트 의존 — 서버 reboot 시 시간대 바뀌면 결과 다름
4

5
// Good — 서비스 표준 TZ
6
std::string s = absl::FormatTime(absl::RFC3339_full, t, absl::UTCTimeZone());

1
// 회피
2
absl::Status Handle(const Request& req) {
3
    CHECK(!req.user_id().empty());   // ❌ 사용자가 빈 ID 보내면 서버 죽음
4
}
5

6
// Good
7
absl::Status Handle(const Request& req) {
8
    if (req.user_id().empty()) {
9
        return absl::InvalidArgumentError("user_id required");
10
    }
11
}

1
// 회피
2
absl::string_view sv = absl::StrCat("prefix-", suffix);   // ❌ 임시 string
3

4
// Good
5
std::string s = absl::StrCat("prefix-", suffix);
6
absl::string_view sv = s;   // s 살아 있는 동안 OK

1
// 회피
2
auto it = set.find(key);
3
set.insert(new_key);   // ❌ 재해싱 시 it invalidate
4
if (it != set.end()) use(*it);
5

6
// Good — insert 후 다시 find 또는 insert 전에 사용
7
auto it = set.find(key);
8
if (it != set.end()) use(*it);   // 먼저 사용
9
set.insert(new_key);

1
// 회피
2
int main(int argc, char** argv) {
3
    LOG(INFO) << "start";   // ❌ log 초기화 전 — flag 미적용
4
}
5

6
// Good
7
int main(int argc, char** argv) {
8
    absl::ParseCommandLine(argc, argv);
9
    absl::InitializeSymbolizer(argv[0]);
10
    absl::InstallFailureSignalHandler({});
11
    absl::InitializeLog();
12
    LOG(INFO) << "start";
13
}