Abseil Code Review · 53/79

absl::any 분석

2026년 6월 12일 · Hawk · 2분 읽기

#std::any의 polyfill

C++17 std::any와 동일 인터페이스. C++17 이상 빌드에서는 std::any의 별칭.

1
#include "absl/types/any.h"
2

3
absl::any a = 42;
4
a = std::string("hello");
5
a = std::vector<int>{1, 2, 3};
6

7
if (a.has_value()) {
8
    auto v = absl::any_cast<std::vector<int>>(a);
9
}

#variant와의 차이

측면	`absl::variant<Ts...>`	`absl::any`
가능한 타입	컴파일 타임에 닫힌 집합	임의 (`open`)
sizeof	`max(sizeof Ts)`	보통 32바이트 (포인터 + 컨트롤)
큰 객체	inline	힙 할당 (SBO 가능)
접근	`holds_alternative` / `get`	`any_cast<T>`
visit	`absl::visit` 지원	없음 — 타입을 알아야 cast
컴파일 시 검증	모든 alternative 강제 처리	런타임 cast 실패

variant는 알려진 닫힌 집합에, any는 플러그인·생명주기 컨테이너 같이 무엇이 들어올지 모를 때 쓴다.

#사용 — any_cast

1
absl::any a = std::string("hello");
2

3
// 값 cast (복사)
4
auto s = absl::any_cast<std::string>(a);   // string 복사
5

6
// reference cast (소유권 없음)
7
auto& r = absl::any_cast<std::string&>(a);
8

9
// pointer cast (실패하면 nullptr)
10
if (auto* p = absl::any_cast<std::string>(&a)) {
11
    use(*p);
12
}

any_cast<T>(any&)는 잘못된 타입이면 bad_any_cast throw. 안전한 시도는 pointer 버전.

#사용 예 — 플러그인 메타데이터

1
class Plugin {
2
public:
3
    virtual ~Plugin() = default;
4
    virtual void Run() = 0;
5

6
    void SetUserData(absl::any data) { user_data_ = std::move(data); }
7
    template <typename T>
8
    T* GetUserData() { return absl::any_cast<T>(&user_data_); }
9

10
private:
11
    absl::any user_data_;
12
};
13

14
// 호출자
15
plugin.SetUserData(std::string("config"));
16
if (auto* s = plugin.GetUserData<std::string>()) {
17
    LOG(INFO) << "config = " << *s;
18
}

플러그인이 들고 다닐 타입을 라이브러리가 모를 때 적합. 단, 잘못된 cast는 런타임 에만 발견되므로 강한 타입을 우선한다.

#비용

작업	비용
작은 객체(보통 16바이트 이하)	inline storage — 할당 없음
큰 객체	힙 할당(`new`)
`any_cast<T>`	typeid 비교 (대부분 RTTI 활용)
복사	내부 타입의 복사 비용

RTTI 비활성화 빌드(-fno-rtti)에서는 any 사용 불가. Google 코드는 RTTI를 거의 안 쓰는데, any 도입 시 이 점을 의식해야 한다.

#회피 패턴

1
// 회피 — variant로 충분한데 any 사용
2
absl::any color;   // ❌ 무엇이 들어가지?
3
color = "red";
4

5
// Good — 닫힌 집합은 variant
6
enum class Color { kRed, kGreen, kBlue };
7
absl::variant<Color, std::string /*hex*/> color;

1
// 회피 — any를 API 경계로 흘리기
2
absl::any Compute();   // ❌ 반환 타입을 호출자가 추측?
3

4
// Good — 의도가 명확한 타입
5
absl::StatusOr<Result> Compute();
6
absl::variant<Success, RateLimited, Error> Compute();

1
// 회피 — RTTI 없는 빌드에서 any
2
// 컴파일은 되지만 typeid가 빈 정보 → cast 실패

#작은 예시 — 이벤트 디스패처

1
class Dispatcher {
2
public:
3
    using Handler = std::function<void(const absl::any&)>;
4

5
    template <typename T>
6
    void Subscribe(std::function<void(const T&)> fn) {
7
        handlers_[std::type_index(typeid(T))] =
8
            [fn = std::move(fn)](const absl::any& a) {
9
                if (auto* p = absl::any_cast<T>(&a)) {
10
                    fn(*p);
11
                }
12
            };
13
    }
14

15
    void Dispatch(const absl::any& event) {
16
        auto it = handlers_.find(std::type_index(event.type()));
17
        if (it != handlers_.end()) it->second(event);
18
    }
19

20
private:
21
    absl::flat_hash_map<std::type_index, Handler> handlers_;
22
};