C++ std::any vs void*: 타입 안전성·크기·성능 비교와 void*가 필요한 곳
이 글의 핵심
void*는 가볍지만 원래 타입을 개발자가 따로 기억해야 해서 잘못 캐스팅하면 오류 없이 메모리를 망가뜨립니다. std::any는 타입 정보를 함께 저장해 잘못된 접근을 예외로 알려 주는 대신 할당과 검사 비용이 듭니다. 두 방식의 선택 기준과 디버깅·코드 리뷰에서 확인할 점을 정리했습니다.
아무 타입이나 담아야 할 때의 두 가지 선택
C++에서 타입을 미리 정하지 않고 값을 저장하는 전통적인 방법은 void*이고, C++17부터는 std::any도 쓸 수 있습니다. 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* ip = (int*)ptr; // 올바른 캐스팅 (수동)
std::cout << *ip << '\n';
delete ip;
// std::any: 타입 안전
std::any value = 42;
// auto d = std::any_cast<double>(value); // 예외 던짐
auto iv = 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 호환 | O | X |
| 성능 | 포인터 복사만 (할당은 별도로 직접) | 작은 타입은 내부 버퍼, 큰 타입은 힙 할당 + 타입 검사 |
| 저장 가능한 타입 | 무엇이든 (주소만 저장) | 복사 생성 가능한 타입만 |
| 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)로 참조를 받거나 포인터 버전을 쓰는 편이 효율적이고, 더 이상 value가 필요 없다면 any_cast<T>(std::move(value))로 값을 이동해 꺼낼 수 있습니다.
“정확히 같은 타입” 규칙은 상속도 고려하지 않습니다. Derived 객체를 넣고 any_cast<Base>나 any_cast<Base&>로 꺼내면 bad_any_cast입니다. 다형성이 필요하다면 std::shared_ptr<Base>처럼 기반 타입 포인터로 정규화해서 넣어야 합니다. 참조도 그대로는 담을 수 없어서 std::any a = x;는 x의 복사본을 저장하고, 원본을 가리키게 하려면 std::any a = std::ref(x);로 넣은 뒤 any_cast<std::reference_wrapper<int>>(a).get()으로 꺼냅니다. 이때는 x의 수명을 호출하는 쪽이 책임져야 합니다. 또 type()과 any_cast는 typeid 비교에 의존하므로 -fno-rtti로 빌드하는 프로젝트에서는 type()을 쓸 수 없거나 구현마다 동작이 달라진다는 점도 도입 전에 확인해야 합니다.
잘못된 타입으로 꺼낼 때 무슨 일이 생기나
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'; // 0 (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'; // 구현마다 다름64비트 환경에서 sizeof(std::any)는 libstdc++가 16바이트(포인터 하나 크기의 내부 버퍼 + 관리 함수 포인터), libc++가 32바이트(포인터 세 개 크기의 버퍼 + 관리 함수 포인터), MSVC가 64바이트입니다. 내부 버퍼 크기가 다르므로 같은 타입이라도 어떤 구현에서는 힙 할당이 일어나고 어떤 구현에서는 일어나지 않습니다.
큰 타입을 넣을 때의 힙 할당
// void*: 수동 할당
void* ptr = malloc(sizeof(int));
*static_cast<int*>(ptr) = 42;
free(ptr);
// std::any: 자동 관리
std::any value = 42; // 작은 값: SBO (힙 할당 없음)
// std::string 객체(32바이트 안팎)는 libstdc++에서는 내부 버퍼(8바이트)에 들어가지 않아
// any가 힙에 따로 저장하고, libc++·MSVC에서는 내부 버퍼에 들어갈 수 있음
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}; // 세 구현 모두 내부 버퍼에 저장 (힙 할당 없음)
std::any large = LargeObject{}; // 어느 구현에서도 버퍼보다 커서 힙 할당설정 저장소·이벤트·플러그인·DB 행 구현
문자열 키 설정 저장소
#include <iostream>
#include <string>
#include <map>
#include <optional>
#include <any>
// 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>이 더 안전한 선택입니다.
임의 페이로드를 싣는 이벤트 시스템
#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <functional>
#include <utility>
#include <any>
// 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'});
}플러그인 시스템
#include <iostream>
#include <vector>
#include <string>
#include <memory>
#include <algorithm>
#include <any>
// 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
}
}
}
}데이터베이스 행의 컬럼 값
// 실무 예시: 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에 원시 포인터를 담으면 타입 확인은 되지만 수명 관리는 여전히 호출자 책임이라는 점도 함께 기억하세요.
상속 계층을 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는 “무엇이 들어 있는지 꺼내는 쪽이 이미 알고 있는” 경우에 쓰는 도구입니다.
잘못된 캐스팅·빈 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 비교가 들어가고 컴파일러가 루프를 단순화하기 어려워집니다. 담는 타입이 내부 버퍼보다 크면 여기에 힙 할당까지 더해집니다. 핫 루프에서 타입이 이미 정해져 있다면 std::any를 거치지 말고 그 타입을 그대로 쓰고, 타입이 몇 가지로 제한된다면 std::variant, 호출 지점마다 타입이 다르다면 템플릿을 쓰는 것이 맞습니다.
// 타입이 제한적일 때
std::variant<int, double, std::string> value;
// 호출 지점에서 타입이 정해질 때
template <typename T>
void process(T value) { /* ... */ }void*만 받아서 타입을 알 수 없을 때
// 타입 정보 없음
void* data = getUserData();
// 어떤 타입인지 모름void*로 바뀐 순간 타입 정보는 사라지므로, 받는 쪽에서 되살릴 방법은 없습니다. std::any data = getUserData();처럼 감싸도 any가 기억하는 타입은 void*일 뿐이라 도움이 되지 않습니다. 고치려면 값을 넣는 쪽에서 타입 정보를 함께 넘겨야 합니다. 경계를 바꿀 수 없다면 타입 태그를 붙인 구조체를 넘기고, 바꿀 수 있다면 원래 타입이 알려진 지점에서 std::any나 std::variant에 담아 넘깁니다.
// 넣는 쪽에서 태그를 함께 넘김
enum class DataType { INT, STRING, CUSTOM };
struct TaggedData {
DataType type;
void* data;
};어느 쪽을 고를까
저장할 타입 목록을 컴파일 시점에 안다면 std::variant나 템플릿이 먼저이고, 공통 인터페이스가 있다면 가상 함수와 std::unique_ptr<Base>가 맞습니다. 타입 목록이 열려 있고 꺼내는 쪽이 무엇을 꺼낼지 알고 있을 때 std::any를 쓰고, void*는 C API처럼 인터페이스가 이미 정해진 경계에서만 쓰되 그 자리에서 바로 원래 타입으로 되돌립니다. 타입 소거를 직접 구현하는 방법은 C++ 타입 소거 패턴에서 이어서 다룹니다.