C++ std::any vs void* | "타입 소거" 안전한 선택

· 12분 읽기 · 수정 중급 비교
C++ std::any vs void* | "타입 소거" 안전한 선택

이 글의 핵심

C++ std::any vs void*에 대한 실전 가이드입니다.

들어가며: “모든 타입을 저장하고 싶어요"

"void*를 쓰면 타입 안전성이 없어요”

C++에서 모든 타입을 저장하려면 void나 std::any(C++17)를 사용합니다. any는 타입 안전하지만, void는 수동 관리가 필요합니다.

비유로 말씀드리면, void*는 라벨 없는 상자에 물건을 넣고 꺼낼 때 직접 종이를 확인해야 하는 것이고, std::any는 상자 안에 타입 영수증이 같이 들어 있는 것에 가깝습니다. 잘못 꺼내면 any_cast가 예외로 알려 줍니다.

언제 std::any를, 언제 void*를 쓰나요?

관점std::anyvoid*
성능타입 정보 유지 비용가장 단순하지만 캐스팅 책임은 호출자
사용성any_cast로 잘못된 타입 탐지C API·드라이버 등과 맞출 때 필수인 경우가 많음
적용 시나리오플러그인 데이터·설정 값 등FFI, 레거시, 저수준
// ❌ void*: 타입 불안전
void* ptr = new int(42);
// double* d = (double*)ptr;  // ❌ 잘못된 캐스팅 → 미정의 동작
int* i = (int*)ptr;  // ✅ 올바른 캐스팅 (수동)
std::cout << *i << '\n';
delete i;

// ✅ std::any: 타입 안전
std::any value = 42;
// auto d = std::any_cast<double>(value);  // ❌ 예외 던짐
auto i = std::any_cast<int>(value);  // ✅ 42

이 글에서 다루는 것:

  • std::any vs void 차이*
  • 타입 안전성
  • 성능 비교
  • 실전 선택 가이드

목차

  1. std::any vs void* 차이
  2. 타입 안전성
  3. 성능 비교
  4. 실전 예시
  5. 정리

1. std::any vs void* 차이

비교표

항목void*std::any
타입 안전성❌ 없음✅ 있음
타입 정보❌ 없음✅ 유지
생성자/소멸자수동자동
캐스팅static_castany_cast
잘못된 캐스팅미정의 동작예외 던짐
메모리 관리수동자동
C 호환✅❌
성능빠름느림 (힙 할당)
C++ 버전모든 버전C++17 이후

void*: 타입 불안전

// ❌ void*: 수동 타입 관리
void* ptr = new int(42);

// 타입 정보 없음
// std::cout << *ptr << '\n';  // 컴파일 에러

// 수동 캐스팅
int* i = static_cast<int*>(ptr);
std::cout << *i << '\n';  // 42

// 잘못된 캐스팅 → 미정의 동작
double* d = static_cast<double*>(ptr);
std::cout << *d << '\n';  // ❌ 쓰레기 값

// 수동 해제
delete i;

std::any: 타입 안전

// ✅ std::any: 자동 타입 관리
std::any value = 42;

// 타입 확인
if (value.type() == typeid(int)) {
    std::cout << "int 타입\n";
}

// 안전한 캐스팅
try {
    auto i = std::any_cast<int>(value);
    std::cout << i << '\n';  // 42
    
    auto d = std::any_cast<double>(value);  // ❌ 예외
} catch (const std::bad_any_cast& e) {
    std::cout << "잘못된 타입: " << e.what() << '\n';
}

// 포인터로 접근 (nullptr 반환)
if (auto* ptr = std::any_cast<int>(&value)) {
    std::cout << *ptr << '\n';  // 42
}

// 자동 소멸

2. 타입 안전성

void*: 타입 추적 필요

// ❌ void*: 수동 타입 추적
enum class Type {
    INT, DOUBLE, STRING
};

struct Value {
    Type type;
    void* data;
    
    Value(int value) : type(Type::INT) {
        data = new int(value);
    }
    
    Value(double value) : type(Type::DOUBLE) {
        data = new double(value);
    }
    
    Value(const std::string& value) : type(Type::STRING) {
        data = new std::string(value);
    }
    
    ~Value() {
        switch (type) {
            case Type::INT:
                delete static_cast<int*>(data);
                break;
            case Type::DOUBLE:
                delete static_cast<double*>(data);
                break;
            case Type::STRING:
                delete static_cast<std::string*>(data);
                break;
        }
    }
    
    // 복사/이동 생성자도 구현 필요...
};

std::any: 자동 타입 관리

// ✅ std::any: 자동 타입 관리
std::any value = 42;
value = 3.14;
value = std::string("Hello");

// 타입 확인
std::cout << value.type().name() << '\n';  // class std::basic_string...

// has_value()
if (value.has_value()) {
    std::cout << "값 있음\n";
}

// reset()
value.reset();
std::cout << value.has_value() << '\n';  // false

3. 성능 비교

벤치마크

#include <benchmark/benchmark.h>
#include <any>

// void*
static void BM_VoidPointer(benchmark::State& state) {
    for (auto _ : state) {
        void* ptr = new int(42);
        int* i = static_cast<int*>(ptr);
        int x = *i;
        delete i;
        benchmark::DoNotOptimize(x);
    }
}
BENCHMARK(BM_VoidPointer);

// std::any
static void BM_StdAny(benchmark::State& state) {
    for (auto _ : state) {
        std::any value = 42;
        int x = std::any_cast<int>(value);
        benchmark::DoNotOptimize(x);
    }
}
BENCHMARK(BM_StdAny);

결과 (GCC 13, -O3):

BM_VoidPointer    50 ns  (힙 할당)
BM_StdAny        100 ns  (힙 할당 + 타입 정보)

메모리 크기

void* ptr = nullptr;
std::cout << sizeof(ptr) << '\n';  // 8 (포인터 크기)

std::any value;
std::cout << sizeof(value) << '\n';  // 16~32 (구현마다 다름)

4. 실전 예시

예시 1: 설정 저장소

// ✅ std::any: 설정 저장소
class Config {
    std::map<std::string, std::any> values_;
    
public:
    template <typename T>
    void set(const std::string& key, T value) {
        values_[key] = value;
    }
    
    template <typename T>
    std::optional<T> get(const std::string& key) const {
        auto it = values_.find(key);
        if (it != values_.end()) {
            try {
                return std::any_cast<T>(it->second);
            } catch (const std::bad_any_cast&) {
                return std::nullopt;
            }
        }
        return std::nullopt;
    }
    
    template <typename T>
    T getOr(const std::string& key, T defaultValue) const {
        return get<T>(key).value_or(defaultValue);
    }
};

int main() {
    Config config;
    
    config.set("port", 8080);
    config.set("host", std::string("localhost"));
    config.set("timeout", 30.0);
    
    auto port = config.get<int>("port");
    if (port) {
        std::cout << "포트: " << *port << '\n';  // 8080
    }
    
    auto host = config.getOr<std::string>("host", "0.0.0.0");
    std::cout << "호스트: " << host << '\n';  // localhost
}

예시 2: 이벤트 시스템

// ✅ std::any: 이벤트 데이터
struct Event {
    std::string type;
    std::any data;
};

class EventBus {
    std::unordered_map<std::string, std::vector<std::function<void(const Event&)>>> listeners_;
    
public:
    void on(const std::string& eventType, std::function<void(const Event&)> listener) {
        listeners_[eventType].push_back(listener);
    }
    
    void emit(const Event& event) {
        auto it = listeners_.find(event.type);
        if (it != listeners_.end()) {
            for (auto& listener : it->second) {
                listener(event);
            }
        }
    }
};

int main() {
    EventBus bus;
    
    // 클릭 이벤트
    bus.on("click",  {
        if (auto* pos = std::any_cast<std::pair<int, int>>(&e.data)) {
            std::cout << "클릭 위치: (" << pos->first << ", " << pos->second << ")\n";
        }
    });
    
    // 키 이벤트
    bus.on("keypress",  {
        if (auto* key = std::any_cast<char>(&e.data)) {
            std::cout << "키 입력: " << *key << '\n';
        }
    });
    
    bus.emit({"click", std::make_pair(100, 200)});
    bus.emit({"keypress", 'A'});
}

예시 3: 플러그인 시스템

// ✅ std::any: 플러그인 데이터
class Plugin {
public:
    virtual ~Plugin() = default;
    virtual std::string name() const = 0;
    virtual std::any execute(const std::any& input) = 0;
};

class UpperCasePlugin : public Plugin {
public:
    std::string name() const override {
        return "UpperCase";
    }
    
    std::any execute(const std::any& input) override {
        if (auto* str = std::any_cast<std::string>(&input)) {
            std::string result = *str;
            std::transform(result.begin(), result.end(), result.begin(), ::toupper);
            return result;
        }
        return std::any{};
    }
};

class MultiplyPlugin : public Plugin {
public:
    std::string name() const override {
        return "Multiply";
    }
    
    std::any execute(const std::any& input) override {
        if (auto* num = std::any_cast<int>(&input)) {
            return *num * 2;
        }
        return std::any{};
    }
};

int main() {
    std::vector<std::unique_ptr<Plugin>> plugins;
    plugins.push_back(std::make_unique<UpperCasePlugin>());
    plugins.push_back(std::make_unique<MultiplyPlugin>());
    
    for (auto& plugin : plugins) {
        std::cout << "플러그인: " << plugin->name() << '\n';
        
        if (plugin->name() == "UpperCase") {
            auto result = plugin->execute(std::string("hello"));
            if (auto* str = std::any_cast<std::string>(&result)) {
                std::cout << "결과: " << *str << '\n';  // HELLO
            }
        } else if (plugin->name() == "Multiply") {
            auto result = plugin->execute(42);
            if (auto* num = std::any_cast<int>(&result)) {
                std::cout << "결과: " << *num << '\n';  // 84
            }
        }
    }
}

void* 사용 사례

C 라이브러리 인터페이스

// ✅ void*: C 호환
extern "C" {
    typedef void (*Callback)(void* userData);
    
    void register_callback(Callback callback, void* userData);
}

void myCallback(void* userData) {
    int* count = static_cast<int*>(userData);
    ++(*count);
}

int main() {
    int count = 0;
    register_callback(myCallback, &count);
}

정리

std::any vs void* 선택

상황사용
타입 안전성std::any
다양한 타입std::any
자동 메모리 관리std::any
C 호환void*
성능 중요void*
단순 포인터void*

핵심 규칙

  1. 기본: std::any (타입 안전)
  2. C 호환: void*
  3. 성능 중요: void*
  4. 자동 관리: std::any

체크리스트

  • 타입 안전성이 필요한가?
  • C 호환이 필요한가?
  • 성능이 매우 중요한가?
  • 자동 메모리 관리가 필요한가?

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

  • C++ std::any 기초 | 완벽 가이드
  • C++ 포인터 기초 | Pointer 가이드
  • C++ 타입 소거 | Type Erasure
  • C++ std::variant | 타입 안전 union

이 글에서 다루는 키워드 (관련 검색어)

std::any, void pointer, any vs void*, 타입 소거, 타입 안전성 등으로 검색하시면 이 글이 도움이 됩니다.

실전 팁

실무에서 바로 적용할 수 있는 팁입니다.

디버깅 팁

  • std::any는 type()로 타입을 확인하세요
  • any_cast는 잘못된 타입 시 예외를 던집니다
  • void*는 타입 추적을 수동으로 해야 합니다

성능 팁

  • std::any는 힙 할당이 발생할 수 있습니다
  • void*가 더 빠르지만 타입 안전성이 없습니다
  • 성능이 중요하면 void*를 고려하세요

코드 리뷰 팁

  • void*를 std::any로 바꾸세요 (타입 안전성)
  • C 호환이 필요한 경우만 void*를 사용하세요
  • any_cast로 안전하게 타입을 변환하세요

자주 하는 실수

실수 1: void* 잘못된 캐스팅

// ❌ 실수: 타입 불일치
void* ptr = new int(42);
double* d = static_cast<double*>(ptr);  // ❌ 잘못된 캐스팅
std::cout << *d << '\n';  // 미정의 동작

// ✅ std::any 사용
std::any value = 42;
try {
    auto d = std::any_cast<double>(value);  // 예외 던짐
} catch (const std::bad_any_cast&) {
    std::cout << "타입 불일치\n";
}

실수 2: any 빈 값 접근

// ❌ 실수: 빈 any 접근
std::any value;
auto x = std::any_cast<int>(value);  // ❌ 예외 던짐

// ✅ has_value() 체크
std::any value;
if (value.has_value()) {
    auto x = std::any_cast<int>(value);
}

실수 3: void* 메모리 누수

// ❌ 실수: 타입별 해제 누락
void* ptr = new std::string("Hello");
delete ptr;  // ❌ std::string 소멸자 호출 안 됨

// ✅ 올바른 해제
std::string* str = new std::string("Hello");
delete str;

// ✅ std::any 사용 (자동 해제)
std::any value = std::string("Hello");
// 자동으로 소멸자 호출

실무 트러블슈팅

문제: any 성능 저하

증상:

// 반복문에서 any 사용 시 느림
for (int i = 0; i < 1000000; ++i) {
    std::any value = i;
    int x = std::any_cast<int>(value);
}

원인: 힙 할당 + 타입 정보 오버헤드

해결:

// 1. 타입 명시
int values[1000000];
for (int i = 0; i < 1000000; ++i) {
    values[i] = i;
}

// 2. variant 사용 (타입이 제한적일 때)
std::variant<int, double, std::string> value;

// 3. 템플릿 사용
template <typename T>
void process(T value) { /* ... */ }

문제: void* 타입 추적

증상:

// 타입 정보 없음
void* data = getUserData();
// 어떤 타입인지 모름

해결:

// 1. 태그 추가
enum class DataType { INT, STRING, CUSTOM };
struct TaggedData {
    DataType type;
    void* data;
};

// 2. std::any 사용
std::any data = getUserData();
std::cout << data.type().name() << '\n';

성능 분석 상세

메모리 할당 패턴

// void*: 수동 할당
void* ptr = malloc(sizeof(int));
*static_cast<int*>(ptr) = 42;
free(ptr);

// std::any: 자동 관리
std::any value = 42;  // 작은 값: SBO (힙 할당 없음)

std::any value2 = std::string("Hello World Hello World");  // 큰 값: 힙 할당

SBO (Small Buffer Optimization)

// std::any의 SBO
struct SmallObject {
    int x, y;  // 8바이트
};

struct LargeObject {
    std::array<int, 100> data;  // 400바이트
};

std::any small = SmallObject{1, 2};  // SBO (힙 할당 없음)
std::any large = LargeObject{};      // 힙 할당

베스트 프랙티스

1. 타입 소거 패턴

// ✅ 타입 소거 인터페이스
class IDrawable {
public:
    virtual ~IDrawable() = default;
    virtual void draw() = 0;
};

class Circle : public IDrawable {
public:
    void draw() override {
        std::cout << "Circle\n";
    }
};

// std::any로 저장
std::vector<std::any> drawables;
drawables.push_back(Circle{});

// 사용
for (auto& item : drawables) {
    if (auto* drawable = std::any_cast<Circle>(&item)) {
        drawable->draw();
    }
}

2. 플러그인 시스템

// ✅ 플러그인 데이터
class PluginContext {
    std::unordered_map<std::string, std::any> data_;
    
public:
    template <typename T>
    void set(const std::string& key, T value) {
        data_[key] = value;
    }
    
    template <typename T>
    std::optional<T> get(const std::string& key) const {
        auto it = data_.find(key);
        if (it != data_.end()) {
            try {
                return std::any_cast<T>(it->second);
            } catch (const std::bad_any_cast&) {
                return std::nullopt;
            }
        }
        return std::nullopt;
    }
    
    bool has(const std::string& key) const {
        return data_.find(key) != data_.end();
    }
};

3. 코드 리뷰 체크포인트

// 🔍 리뷰 시 확인사항

// 1. void* 타입 추적
void* data = getData();  // ⚠️ 타입 정보?

// 2. any 타입 체크
std::any_cast<int>(value);  // ⚠️ 예외 처리?

// 3. 메모리 관리
void* ptr = malloc(100);  // ⚠️ free 호출?

// 4. 성능
for (/* 많은 반복 */) {
    std::any value = i;  // ⚠️ 성능 문제?
}

실무 시나리오

시나리오 1: 스크립팅 엔진

// ✅ 실무 예시: 스크립트 변수
class ScriptEngine {
    std::unordered_map<std::string, std::any> globals_;
    
public:
    void setGlobal(const std::string& name, std::any value) {
        globals_[name] = value;
    }
    
    std::any getGlobal(const std::string& name) const {
        auto it = globals_.find(name);
        if (it != globals_.end()) {
            return it->second;
        }
        return std::any{};
    }
    
    void execute(const std::string& code) {
        // 스크립트 실행
        // 변수 접근 시 globals_ 사용
    }
};

// 사용
ScriptEngine engine;
engine.setGlobal("playerHealth", 100);
engine.setGlobal("playerName", std::string("Hero"));
engine.setGlobal("position", glm::vec3(0, 0, 0));

engine.execute("print(playerName + ' has ' + playerHealth + ' HP')");

시나리오 2: 이벤트 시스템

// ✅ 실무 예시: 이벤트 데이터
struct Event {
    std::string type;
    std::any data;
    std::chrono::system_clock::time_point timestamp;
    
    Event(std::string type, std::any data)
        : type(std::move(type)),
          data(std::move(data)),
          timestamp(std::chrono::system_clock::now()) {}
};

class EventBus {
    std::unordered_map<std::string, 
                      std::vector<std::function<void(const Event&)>>> listeners_;
    
public:
    void on(const std::string& eventType, 
            std::function<void(const Event&)> listener) {
        listeners_[eventType].push_back(listener);
    }
    
    void emit(const Event& event) {
        auto it = listeners_.find(event.type);
        if (it != listeners_.end()) {
            for (auto& listener : it->second) {
                listener(event);
            }
        }
    }
};

// 사용
EventBus bus;

// 다양한 타입의 이벤트
bus.on("click",  {
    if (auto* pos = std::any_cast<std::pair<int, int>>(&e.data)) {
        std::cout << "클릭: (" << pos->first << ", " << pos->second << ")\n";
    }
});

bus.on("keypress",  {
    if (auto* key = std::any_cast<char>(&e.data)) {
        std::cout << "키: " << *key << '\n';
    }
});

bus.on("custom",  {
    if (auto* data = std::any_cast<CustomData>(&e.data)) {
        std::cout << "커스텀: " << data->value << '\n';
    }
});

bus.emit(Event("click", std::make_pair(100, 200)));
bus.emit(Event("keypress", 'A'));

시나리오 3: 데이터베이스 행

// ✅ 실무 예시: DB 행
class Row {
    std::unordered_map<std::string, std::any> columns_;
    
public:
    template <typename T>
    void set(const std::string& column, T value) {
        columns_[column] = value;
    }
    
    template <typename T>
    std::optional<T> get(const std::string& column) const {
        auto it = columns_.find(column);
        if (it != columns_.end()) {
            try {
                return std::any_cast<T>(it->second);
            } catch (const std::bad_any_cast&) {
                return std::nullopt;
            }
        }
        return std::nullopt;
    }
    
    std::string toString(const std::string& column) const {
        auto it = columns_.find(column);
        if (it == columns_.end()) {
            return "NULL";
        }
        
        const auto& value = it->second;
        const auto& type = value.type();
        
        if (type == typeid(int)) {
            return std::to_string(std::any_cast<int>(value));
        } else if (type == typeid(double)) {
            return std::to_string(std::any_cast<double>(value));
        } else if (type == typeid(std::string)) {
            return std::any_cast<std::string>(value);
        } else if (type == typeid(bool)) {
            return std::any_cast<bool>(value) ? "true" : "false";
        }
        
        return "UNKNOWN";
    }
};

// 사용
Row row;
row.set("id", 1);
row.set("name", std::string("Alice"));
row.set("age", 30);
row.set("active", true);

auto name = row.get<std::string>("name");  // std::optional<std::string>
std::cout << "ID: " << row.toString("id") << '\n';
std::cout << "Name: " << row.toString("name") << '\n';

void* 레거시 코드 마이그레이션

Before (void*)

// ❌ 레거시 코드
void* userData = nullptr;

void setUserData(void* data) {
    userData = data;
}

void* getUserData() {
    return userData;
}

// 사용
int* count = new int(42);
setUserData(count);
int* retrieved = static_cast<int*>(getUserData());

After (std::any)

// ✅ 현대 C++
std::any userData;

void setUserData(std::any data) {
    userData = data;
}

std::any getUserData() {
    return userData;
}

// 사용
setUserData(42);
if (auto* count = std::any_cast<int>(&getUserData())) {
    std::cout << *count << '\n';
}

마치며

std::any는 타입 안전하고 사용하기 쉽지만, void*는 C 호환과 성능에 적합합니다.

핵심 원칙:

  1. 기본: std::any
  2. C 호환: void*
  3. 타입 안전성 우선

실무 팁:

  • 스크립팅 엔진, 이벤트 시스템, DB 행에 활용
  • 타입 체크는 any_cast + 예외 처리
  • 레거시 void* 코드는 std::any로 마이그레이션

타입 안전성이 중요하면 std::any를 사용하세요.

다음 단계: std::any를 이해했다면, C++ 타입 소거 패턴에서 더 깊이 배워보세요.

관련 글

  • C++ 시리즈 전체 보기
  • C++ Adapter Pattern 완벽 가이드 | 인터페이스 변환과 호환성
  • C++ ADL |
  • C++ Aggregate Initialization |