C++ std::any vs void*: 타입 안전성·크기·성능 비교와 void*가 필요한 곳

아무 타입이나 담아야 할 때의 두 가지 선택

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

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

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

관점	std::any	void*
성능	타입 정보 유지 비용	가장 단순하지만 캐스팅 책임은 호출자
사용성	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::variant<int, double, std::string>이 대부분의 경우 더 낫습니다. 힙 할당이 없고, std::visit로 모든 경우를 처리했는지 컴파일러가 확인해 줍니다. 타입 목록이 열려 있어서(플러그인이 새 타입을 가져오는 등) 미리 알 수 없을 때가 std::any의 영역이고, C 라이브러리처럼 인터페이스가 이미 void*로 정해져 있을 때가 void*의 영역입니다. 이 글은 뒤의 두 경우를 비교합니다.

---

타입 정보를 함께 들고 있는가

항목별 비교표

항목	void*	std::any
타입 안전성	❌ 없음	✅ 있음
타입 정보	❌ 없음	✅ 유지
생성자/소멸자	수동	자동
캐스팅	static_cast	any_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;

void*가 위험한 핵심은 두 가지 정보를 모두 잃는다는 점입니다. 하나는 “무슨 타입인가”이고, 다른 하나는 “누가 언제 해제하는가”입니다. static_cast<double*>는 컴파일러가 아무 확인 없이 통과시키고, 4바이트 int 자리를 8바이트 double로 읽으면 옆 메모리까지 읽는 범위 초과가 됩니다. 이 코드가 “쓰레기 값”을 출력하는 정도로 끝나면 운이 좋은 편이고, 쓰기까지 하면 힙이 망가져 전혀 다른 곳에서 크래시합니다. 소유권도 코드에 드러나지 않으므로, void*를 받는 쪽은 그것을 해제해야 하는지, 해제한다면 delete인지 free인지 delete[]인지 문서를 보지 않고는 알 수 없습니다.

std::any: 저장한 타입을 typeid로 기억함

// ✅ 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
}

// 자동 소멸

std::any가 타입을 기억하는 방식은 단순합니다. 값을 넣을 때 그 타입 전용의 “관리 함수”(복사, 이동, 소멸, typeid 조회를 담당)에 대한 포인터를 함께 저장합니다. any_cast<int>는 저장된 typeid가 정확히 int인지 비교하고, 같으면 값을, 다르면 bad_any_cast를 돌려줍니다. 여기서 “정확히”가 중요합니다. short를 넣고 int로 꺼내거나, const char*를 넣고 std::string으로 꺼내는 것은 모두 실패합니다. std::any s = "hello";처럼 문자열 리터럴을 넣으면 저장되는 타입은 const char*라서 any_cast<std::string>이 예외를 던지는 것이 가장 흔한 실수입니다.

값 버전 any_cast<T>(value)는 복사본을 돌려준다는 점도 기억해 둘 만합니다. 큰 객체라면 any_cast<const T&>(value)로 참조를 받거나 포인터 버전을 쓰는 편이 효율적입니다.

---

잘못된 타입으로 꺼낼 때 무슨 일이 생기나

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: any_cast가 bad_any_cast로 알려 준다

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

// 타입 확인 (name()의 형식은 구현 정의: MSVC는 "class std::basic_string<...>",
// GCC/Clang은 맹글링된 이름 "NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE")
std::cout << value.type().name() << '\n';

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

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

---

벤치마크·크기·힙 할당과 SBO

any_cast와 static_cast 벤치마크

#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);

이 벤치마크는 결과를 해석할 때 주의가 필요합니다. BM_VoidPointer는 매 반복 new/delete로 힙 할당을 하지만, BM_StdAny의 int는 주요 구현(libstdc++, libc++, MSVC)에서 모두 std::any 내부의 작은 버퍼에 저장되어 힙 할당이 일어나지 않습니다. 그래서 이 코드는 “void* 대 any”보다 “힙 할당 대 내부 버퍼”를 비교하게 되고, 환경에 따라 std::any 쪽이 더 빠르게 나올 수도 있습니다. 공정하게 비교하려면 같은 크기의 큰 타입(예: std::array<int, 64>)을 두 방식 모두에 넣거나, void*가 스택 변수를 가리키게 해서 할당을 빼야 합니다. 절대 수치는 컴파일러, 표준 라이브러리, CPU에 따라 크게 달라지므로 자기 환경에서 직접 돌려 보는 것이 유일하게 믿을 만한 방법입니다.

std::any의 실제 비용은 세 곳에서 생깁니다. 내부 버퍼보다 큰 타입을 넣을 때의 힙 할당, any_cast마다 하는 typeid 비교, 그리고 std::any를 복사할 때 저장된 값 전체의 깊은 복사입니다. 특히 마지막 항목이 자주 간과됩니다. std::map<std::string, std::any>를 값으로 반환하거나 함수 인자로 복사해 넘기면 안에 든 모든 값이 복제됩니다.

sizeof 비교

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

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

큰 타입을 넣을 때의 힙 할당

// 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

// 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{};      // 힙 할당

---

설정 저장소·이벤트·플러그인·스크립팅·DB 행 구현

문자열 키 설정 저장소

// ✅ 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
}

이 설정 저장소에는 std::any의 “정확히 같은 타입” 규칙 때문에 생기는 함정이 있습니다. config.set("port", 8080)은 int로 저장되므로 config.get<long>("port")나 get<unsigned>("port")는 값이 있어도 nullopt을 돌려줍니다. config.set("host", "localhost")처럼 std::string(...) 없이 넣으면 const char*로 저장되어 get<std::string>이 실패합니다. 이런 실수는 컴파일 에러가 아니라 “설정이 없는 것처럼” 동작하는 조용한 실패라 찾기 어렵습니다. 저는 이런 저장소를 만들 때 set에서 문자열 리터럴을 std::string으로 정규화하는 오버로드를 추가하고, get이 타입 불일치로 실패하면 저장된 type().name()을 로그로 남기도록 해서 원인을 바로 알 수 있게 합니다. 설정 값의 타입이 몇 가지로 정해져 있다면 애초에 std::variant<int, double, bool, std::string>이 더 안전한 선택입니다.

임의 페이로드를 싣는 이벤트 시스템

// ✅ 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", [](const Event& e) {
        if (auto* pos = std::any_cast<std::pair<int, int>>(&e.data)) {
            std::cout << "클릭 위치: (" << pos->first << ", " << pos->second << ")\n";
        }
    });
    
    // 키 이벤트
    bus.on("keypress", [](const Event& e) {
        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'});
}

플러그인 시스템

// ✅ 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
            }
        }
    }
}

스크립팅 엔진의 변수 값

// ✅ 실무 예시: 스크립트 변수
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')");

타입별 핸들러를 등록하는 이벤트 버스

// ✅ 실무 예시: 이벤트 데이터
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", [](const Event& e) {
    if (auto* pos = std::any_cast<std::pair<int, int>>(&e.data)) {
        std::cout << "클릭: (" << pos->first << ", " << pos->second << ")\n";
    }
});

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

bus.on("custom", [](const Event& e) {
    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'));

데이터베이스 행의 컬럼 값

// ✅ 실무 예시: 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*가 필요한 곳

C 라이브러리 콜백의 user data

// ✅ 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);
}

C API의 void* userData는 std::any로 대체할 수 없는, void*가 제자리인 경우입니다. 여기서 안전하게 쓰는 요령은 넣을 때와 꺼낼 때 정확히 같은 타입을 쓰는 것입니다. 흔한 버그는 Derived*를 void*로 넘기고 콜백에서 Base*로 꺼내는 경우인데, 다중 상속에서는 Base 부분이 객체 시작 주소와 다른 오프셋에 있어서 잘못된 주소를 쓰게 됩니다. 넣을 때 먼저 static_cast<Base*>로 바꾼 뒤 void*로 넘기면 안전합니다. 또 콜백이 비동기로 나중에 호출된다면 위 예제의 count처럼 스택 변수의 주소를 넘기는 것은 위험합니다. main이 먼저 끝나면 콜백이 해제된 스택을 가리키게 되므로, 콜백의 수명보다 오래 사는 객체를 넘겨야 합니다.

C++ 쪽에서 콜백을 등록할 때는 람다를 쓰고 싶어지는데, 캡처가 없는 람다만 함수 포인터로 변환됩니다. 상태가 필요하면 그 상태를 담은 객체의 주소를 userData로 넘기고, 캡처 없는 람다 안에서 static_cast로 복원하는 방식이 관용구입니다.

---

레거시 void* 코드를 std::any로 옮기기

옮기기 전: 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());

옮긴 후: std::any

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

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

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

// 사용
setUserData(42);
std::any data = getUserData();   // 임시 객체의 주소는 취할 수 없으므로 변수에 담음
if (auto* count = std::any_cast<int>(&data)) {
    std::cout << *count << '\n';
}

마이그레이션 전후는 의미가 조금 다릅니다. 원래 코드는 외부 객체를 가리키는 포인터를 저장했지만, std::any 버전은 값의 복사본을 저장합니다. 원래 코드에서 *retrieved를 수정하면 count가 가리키는 원본이 바뀌었지만, 새 코드에서는 저장된 복사본만 바뀝니다. 기존 동작(공유)을 유지해야 한다면 std::any에 std::shared_ptr<int>를 담거나 포인터(int*)를 담아야 합니다. std::any에 원시 포인터를 담으면 타입 확인은 되지만 수명 관리는 여전히 호출자 책임이라는 점도 함께 기억하세요.

---

타입 소거 설계와 리뷰 기준

직접 만드는 타입 소거 래퍼

// ✅ 타입 소거 인터페이스
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();
    }
}

이 예제는 오히려 std::any를 쓰지 말아야 하는 경우를 보여 줍니다. std::any_cast<IDrawable>(&item)은 Circle이 IDrawable을 상속해도 실패합니다. std::any는 상속 관계를 모르고 정확한 타입만 비교하므로, 도형이 늘어날 때마다 any_cast<Square>, any_cast<Triangle> 분기를 추가해야 합니다. 공통 인터페이스가 이미 있다면 std::vector<std::unique_ptr<IDrawable>>이 맞는 도구이고, 상속 없이 “draw()를 가진 무엇이든”을 담고 싶다면 타입 소거 래퍼를 직접 만드는 것이 std::any보다 낫습니다. std::any는 “무엇이 들어 있는지 꺼내는 쪽이 이미 알고 있는” 경우에 쓰는 도구입니다.

플러그인 인터페이스 설계

// ✅ 플러그인 데이터
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();
    }
};

코드 리뷰 체크포인트

// 🔍 리뷰 시 확인사항

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

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

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

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

---

잘못된 캐스팅·빈 any·누수·복사 불가 타입

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";
}

빈 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);
}

void*가 가리키는 메모리를 해제하지 않음

// ❌ 실수: 타입별 해제 누락
void* ptr = new std::string("Hello");
delete ptr;  // ❌ void* delete는 미정의 동작 (소멸자 미호출 → 내부 버퍼 누수 등)

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

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

void*를 delete하는 코드는 GCC·Clang에서 deleting 'void*' is undefined 경고가 나지만 빌드는 됩니다. 컴파일러가 어떤 소멸자를 불러야 할지, 객체 크기가 얼마인지 알 수 없으므로 표준은 이를 미정의 동작으로 규정합니다. 실제로는 대개 메모리 블록만 반환되고 std::string의 소멸자가 호출되지 않아, 문자열이 따로 할당한 버퍼가 누수됩니다.

unique_ptr 같은 복사 불가 타입을 넣으려 함

std::any a = std::make_unique<int>(1);  // ❌ 컴파일 에러

std::any는 자기 자신을 복사할 수 있어야 하므로 복사 생성 가능한 타입만 담을 수 있습니다. std::unique_ptr, std::thread, std::mutex처럼 이동만 가능한 타입은 넣을 수 없고, 컴파일러는 std::is_copy_constructible 관련 static_assert나 제약 실패 에러를 냅니다. 이동 전용 자원을 담아야 한다면 std::shared_ptr로 감싸거나(std::any a = std::make_shared<Resource>();), C++23의 std::move_only_function처럼 이동 전용을 지원하는 다른 타입 소거 도구를 찾아야 합니다.

반복문 안의 any가 느릴 때

증상:

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

원인: int는 내부 버퍼에 들어가므로 힙 할당은 없지만, 매 반복 관리 함수 호출과 typeid 비교가 들어가고 컴파일러가 루프를 단순화하기 어려워집니다. 담는 타입이 내부 버퍼보다 크면 여기에 힙 할당까지 더해집니다.

해결:

// 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';

---

any와 void* 선택 요약

상황별 선택표

상황	사용
타입 안전성	std::any
다양한 타입	std::any
자동 메모리 관리	std::any
C 호환	void*
타입 목록이 정해져 있음 / 성능 중요	std::variant 또는 템플릿
공통 인터페이스가 있음	가상 함수 + unique_ptr

네 가지 규칙

1. 타입 목록을 안다면: std::variant
2. 타입이 열려 있다면: std::any
3. C 호환: void* (경계에서만, 즉시 원래 타입으로 복원)
4. 자동 관리: std::any

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

---

같이 보면 좋은 글

• C++ std::any 기초
• C++ 포인터 기초 | Pointer 가이드
• C++ 타입 소거 | Type Erasure
• C++ std::variant | 타입 안전 union
• C++ 시리즈 전체 보기

자주 묻는 질문 (FAQ)

Q. std::any_cast는 언제 bad_any_cast를 던지고, 예외 없이 확인하려면 어떻게 하나요?

A. std::any_cast<T>는 저장된 타입과 T가 정확히 같을 때만 성공하며, int를 넣고 long이나 double로 꺼내는 것처럼 암시적 변환이 가능한 경우에도 std::bad_any_cast를 던집니다. 예외를 피하고 싶다면 포인터 버전인 std::any_cast<T>(&value)를 쓰면 실패 시 nullptr을 돌려주므로 if로 분기할 수 있습니다. 이벤트·플러그인 시스템처럼 여러 타입을 번갈아 확인하는 코드에서는 이 포인터 버전이 try/catch보다 읽기 쉽고 비용도 적습니다.