C++ typedef vs using | "타입 별칭" 가이드
이 글의 핵심
C++ typedef vs using에 대한 실전 가이드입니다.
typedef vs using
typedef 와 using (C++11)은 타입에 별칭을 붙이는 기능입니다. using 상세, 템플릿 기초와 함께 보면 템플릿 별칭까지 활용하기 쉽습니다.
// typedef (전통적)
typedef unsigned long ulong;
// using (C++11, 권장)
using ulong = unsigned long;왜 필요한가?:
- 가독성: 긴 타입 이름을 짧게
- 유지보수: 타입 변경 시 한 곳만 수정
- 명확성: 의도를 명확히 표현
- 템플릿 별칭:
using은 템플릿 별칭 가능
// ❌ 긴 타입: 읽기 어려움
std::map<std::string, std::vector<std::pair<int, std::string>>> data;
// ✅ 별칭: 읽기 쉬움
using UserData = std::map<std::string, std::vector<std::pair<int, std::string>>>;
UserData data;typedef vs using 비교:
| 특징 | typedef | using |
|---|---|---|
| 문법 | C 스타일 | 현대적 |
| 가독성 | ❌ 낮음 | ✅ 높음 |
| 템플릿 별칭 | ❌ 불가 | ✅ 가능 |
| 함수 포인터 | ❌ 복잡 | ✅ 명확 |
| 권장 | ❌ 레거시 | ✅ C++11+ |
// typedef: 복잡
typedef void (*FuncPtr)(int, double);
// using: 명확
using FuncPtr = void (*)(int, double);기본 사용
// 긴 타입 단축
typedef std::vector<std::pair<int, std::string>> PairVector;
using PairVector = std::vector<std::pair<int, std::string>>;
// 함수 포인터
typedef void (*FuncPtr)(int);
using FuncPtr = void (*)(int);
// 배열
typedef int IntArray[10];
using IntArray = int[10];실전 예시
예시 1: 컨테이너 별칭
// typedef
typedef std::map<std::string, std::vector<int>> DataMap;
// using (더 읽기 쉬움)
using DataMap = std::map<std::string, std::vector<int>>;
int main() {
DataMap data;
data["numbers"] = {1, 2, 3};
}예시 2: 템플릿 별칭
// ❌ typedef는 템플릿 별칭 불가
template<typename T>
typedef std::vector<T> Vec; // 에러
// ✅ using은 템플릿 별칭 가능
template<typename T>
using Vec = std::vector<T>;
Vec<int> numbers = {1, 2, 3};
Vec<std::string> names = {"Alice", "Bob"};예시 3: 함수 포인터
// typedef (복잡)
typedef int (*Operation)(int, int);
// using (명확)
using Operation = int (*)(int, int);
int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int main() {
Operation op = add;
std::cout << op(10, 5) << std::endl; // 15
}예시 4: 중첩 타입
template<typename T>
class Container {
public:
using value_type = T;
using iterator = T*;
using const_iterator = const T*;
};
Container<int>::value_type x = 10;
Container<int>::iterator it;템플릿 별칭 활용
// 스마트 포인터 별칭
template<typename T>
using UniquePtr = std::unique_ptr<T>;
template<typename T>
using SharedPtr = std::shared_ptr<T>;
// 컨테이너 별칭
template<typename T>
using StringMap = std::map<std::string, T>;
StringMap<int> ages;
ages["Alice"] = 30;자주 발생하는 문제
문제 1: typedef 순서
// ❌ 읽기 어려움
typedef void (*FuncPtr)(int);
// ✅ using이 더 명확
using FuncPtr = void (*)(int);문제 2: 템플릿 별칭
// ❌ typedef 불가
template<typename T>
typedef std::vector<T> Vec;
// ✅ using 사용
template<typename T>
using Vec = std::vector<T>;문제 3: 네임스페이스
namespace MyLib {
using String = std::string;
using StringVector = std::vector<String>;
}
MyLib::String s = "Hello";문제 4: 전방 선언
// typedef
typedef struct Node Node;
// using
using Node = struct Node;
struct Node {
int data;
Node* next;
};권장사항
// ✅ using 권장 (C++11 이후)
using IntVector = std::vector<int>;
using StringMap = std::map<std::string, int>;
// typedef는 레거시 코드에서만
typedef std::vector<int> IntVector;실무 패턴
패턴 1: 플랫폼 독립 타입
// 플랫폼별 타입 정의
#ifdef _WIN32
using FileHandle = void*;
using SocketHandle = unsigned long long;
#else
using FileHandle = int;
using SocketHandle = int;
#endif
// 사용
FileHandle openFile(const std::string& path) {
// 플랫폼 독립적 코드
}패턴 2: STL 컨테이너 별칭
// 자주 사용하는 컨테이너 별칭
template<typename T>
using Vector = std::vector<T>;
template<typename K, typename V>
using Map = std::map<K, V>;
template<typename T>
using Set = std::set<T>;
// 사용
Vector<int> numbers = {1, 2, 3};
Map<std::string, int> ages = {{"Alice", 30}};
Set<std::string> names = {"Bob", "Charlie"};패턴 3: 함수 타입 별칭
// 콜백 타입 정의
using Callback = std::function<void(int)>;
using ErrorHandler = std::function<void(const std::string&)>;
using Validator = std::function<bool(const std::string&)>;
class EventSystem {
std::vector<Callback> callbacks_;
ErrorHandler errorHandler_;
public:
void setErrorHandler(ErrorHandler handler) {
errorHandler_ = std::move(handler);
}
void addCallback(Callback callback) {
callbacks_.push_back(std::move(callback));
}
void trigger(int value) {
for (auto& callback : callbacks_) {
callback(value);
}
}
};FAQ
Q1: typedef vs using의 차이는?
A:
- using: 더 읽기 쉬움, 템플릿 별칭 가능, 권장
- typedef: C 스타일, 템플릿 별칭 불가, 레거시
// typedef: 복잡
typedef std::map<std::string, std::vector<int>> DataMap;
// using: 명확
using DataMap = std::map<std::string, std::vector<int>>;Q2: 언제 사용하나요?
A:
- 긴 타입 단축: 가독성 향상
- 유지보수: 타입 변경 시 한 곳만 수정
- 템플릿 별칭: 제네릭 타입 정의
- 플랫폼 독립: 플랫폼별 타입 추상화
using UserId = int64_t; // 나중에 string으로 변경 가능Q3: 성능 차이는?
A: 없습니다. 컴파일 타임에만 동작하는 별칭입니다.
using IntVector = std::vector<int>;
IntVector v = {1, 2, 3};
// std::vector<int>와 동일한 성능Q4: 템플릿 별칭은 어떻게 만드나요?
A: using만 가능합니다. typedef는 템플릿 별칭을 지원하지 않습니다.
// ❌ typedef: 불가
template<typename T>
typedef std::vector<T> Vec; // 에러
// ✅ using: 가능
template<typename T>
using Vec = std::vector<T>;
Vec<int> numbers = {1, 2, 3};Q5: 권장 방식은?
A: C++11 이후 using 권장합니다. 더 읽기 쉽고 템플릿 별칭을 지원합니다.
// ✅ using 권장
using IntVector = std::vector<int>;
using FuncPtr = void (*)(int);
// ❌ typedef: 레거시
typedef std::vector<int> IntVector;
typedef void (*FuncPtr)(int);Q6: 함수 포인터 별칭은?
A: using이 훨씬 읽기 쉽습니다.
// typedef: 복잡
typedef int (*Operation)(int, int);
// using: 명확
using Operation = int (*)(int, int);
// 또는 std::function
using Operation = std::function<int(int, int)>;Q7: 중첩 타입은 어떻게 정의하나요?
A: 클래스 내부에서 using 을 사용합니다.
template<typename T>
class Container {
public:
using value_type = T;
using iterator = T*;
using const_iterator = const T*;
using size_type = size_t;
};
// 사용
Container<int>::value_type x = 10;
Container<int>::iterator it;Q8: 타입 별칭 학습 리소스는?
A:
- “Effective Modern C++” by Scott Meyers (Item 9)
- “C++ Primer” by Stanley Lippman
- cppreference.com - Type alias
관련 글: using 상세, 템플릿 기초, auto 타입 추론, decltype.
한 줄 요약: using은 타입 별칭을 만드는 C++11 키워드로, typedef보다 읽기 쉽고 템플릿 별칭을 지원합니다.
심화: 의존적 이름(dependent name)과 typename
템플릿 안에서 기본 클래스의 중첩 타입을 가리킬 때는 typename이 필요할 수 있습니다. using으로 꺼내 두면 호출부가 읽기 쉬워집니다.
template<typename T>
struct Wrapper {
using value_type = typename T::value_type; // T에 따라 의존적 이름
};심화: using + 트레일링 리턴 (가독성)
template<typename A, typename B>
auto add(A a, B b) -> decltype(a + b) {
return a + b;
}
// C++14 이후에는 반환 타입 추론과 조합 가능
template<typename F>
using invoke_result_t = std::invoke_result_t<F>; // 결과 타입 별칭심화: SFINAE·std::enable_if와 별칭
template<typename T>
using enable_if_integral_t = std::enable_if_t<std::is_integral_v<T>, int>;
template<typename T, enable_if_integral_t<T> = 0>
int bits(T) { return sizeof(T) * 8; }별칭 덕분에 std::enable_if_t<...> 덩어리를 매번 쓰지 않아도 됩니다.
심화: 성능·ABI
typedef와 using은 컴파일 타임 별칭이라 런타임 비용 차이는 없습니다. 바이너리 크기도 동일한 타입을 가리키면 같습니다. 성능 이슈는 별칭이 가리키는 실제 타입(예: int vs long on LP64)에서 생깁니다.
심화: 디버깅·흔한 실수
| 실수 | 설명 |
|---|---|
템플릿 별칭에 typedef 사용 | C++11 이전 방식의 우회 코드로 복잡해짐 → using으로 통일 |
| 포인터 별칭에서 괄호 위치 | using P = int*; using Arr = P[10]; vs int*[10] 혼동 → 한 줄씩 검증 |
| 매크로와 이름 충돌 | 레거시 #define ulong 같은 매크로가 있으면 using 선언과 충돌 → #undef 또는 이름 변경 |
심화: 실전 예제 — 핸들·콜백 타입 묶기
#include <functional>
#include <string>
using ErrorCode = int;
using AsyncCallback = std::function<void(ErrorCode, std::string)>;
void download(std::string url, AsyncCallback cb) {
// ...
cb(0, "ok");
}API 경계에서 긴 std::function<void(...) 를 반복하지 않게 해 팀 합의와 리뷰가 쉬워집니다.
같이 보면 좋은 글 (내부 링크)
이 주제와 연결되는 다른 글입니다.
- C++ using vs typedef | “타입 별칭” 가이드
- C++ 템플릿 | “제네릭 프로그래밍” 초보자 가이드
- C++ auto 타입 추론 | 복잡한 타입을 컴파일러에 맡기기
- C++ decltype | “타입 추출” 가이드
관련 글
- C++ using vs typedef |
- C++ async & launch |
- C++ Atomic Operations |
- C++ Attributes |
- C++ auto 키워드 |