C++ typedef vs using | '타입 별칭' 가이드
이 글의 핵심
C++ typedef vs using - "타입 별칭" 가이드. C++ typedef vs using의 typedef vs using, 기본 사용, 실전 예시를 실전 코드와 함께 설명합니다.
typedef vs using
typedef 와 using (C++11)은 타입에 별칭을 붙이는 기능입니다. using 상세, 템플릿 기초와 함께 보면 템플릿 별칭까지 활용하기 쉽습니다.
// typedef (전통적)
typedef unsigned long ulong;
// using (C++11, 권장)
using ulong = unsigned long;왜 필요한가?:
- 가독성: 긴 타입 이름을 짧게
- 유지보수: 타입 변경 시 한 곳만 수정
- 명확성: 의도를 명확히 표현
- 템플릿 별칭:
using은 템플릿 별칭 가능
C/C++ 예제 코드입니다.
// ❌ 긴 타입: 읽기 어려움
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: 템플릿 별칭
C/C++ 예제 코드입니다.
// ❌ typedef 불가
template<typename T>
typedef std::vector<T> Vec;
// ✅ using 사용
template<typename T>
using Vec = std::vector<T>;문제 3: 네임스페이스
C/C++ 예제 코드입니다.
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;
};권장사항
C/C++ 예제 코드입니다.
// ✅ using 권장 (C++11 이후)
using IntVector = std::vector<int>;
using StringMap = std::map<std::string, int>;
// typedef는 레거시 코드에서만
typedef std::vector<int> IntVector;실무 패턴
패턴 1: 플랫폼 독립 타입
C/C++ 예제 코드입니다.
// 플랫폼별 타입 정의
#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는 템플릿 별칭을 지원하지 않습니다.
C/C++ 예제 코드입니다.
// ❌ 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 권장합니다. 더 읽기 쉽고 템플릿 별칭을 지원합니다.
C/C++ 예제 코드입니다.
// ✅ using 권장
using IntVector = std::vector<int>;
using FuncPtr = void (*)(int);
// ❌ typedef: 레거시
typedef std::vector<int> IntVector;
typedef void (*FuncPtr)(int);Q6: 함수 포인터 별칭은?
A: using이 훨씬 읽기 쉽습니다.
C/C++ 예제 코드입니다.
// 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 + 트레일링 리턴 (가독성)
add 함수의 구현 예제입니다.
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++ typedef vs using | ‘타입 별칭’ 가이드」)를 구현·런타임·운영 관점에서 다시 압축합니다. 도메인별 세부 구현은 글마다 다르지만, 입력 검증 → 핵심 연산 → 부작용(I/O·네트워크·동시성) → 관측의 흐름으로 장애를 나누면 원인 추적이 빨라집니다.
내부 동작과 핵심 메커니즘
flowchart TD A[입력·요청·이벤트] --> B[파싱·검증·디코딩] B --> C[핵심 연산·상태 전이] C --> D[부작용: I/O·네트워크·동시성] D --> E[결과·관측·저장]
sequenceDiagram participant C as 클라이언트/호출자 participant B as 경계(런타임·게이트웨이·프로세스) participant D as 의존성(API·DB·큐·파일) C->>B: 요청/이벤트 B->>D: 조회·쓰기·RPC D-->>B: 지연·부분 실패·재시도 가능 B-->>C: 응답 또는 오류(코드·상관 ID)
- 불변 조건(Invariant): 버퍼 경계, 프로토콜 상태, 트랜잭션 격리, FD 상한 등 단계별로 문장으로 적어 두면 디버깅 비용이 줄어듭니다.
- 결정성: 순수 층과 시간·네트워크·스케줄에 의존하는 층을 분리해야 테스트와 장애 분석이 쉬워집니다.
- 경계 비용: 직렬화, 인코딩, syscall 횟수, 락 경합, 할당·GC, 캐시 미스를 의심 목록에 둡니다.
- 백프레셔: 생산자가 소비자보다 빠를 때 버퍼·큐·스트림에서 속도를 줄이는 신호를 어디에 둘지 정의합니다.
프로덕션 운영 패턴
| 영역 | 운영 관점 질문 |
|---|---|
| 관측성 | 요청 단위 상관 ID, 에러율·지연 p95/p99, 의존성 타임아웃·재시도가 대시보드에 보이는가 |
| 안전성 | 입력 검증·권한·비밀·감사 로그가 코드 경로마다 일관적인가 |
| 신뢰성 | 재시도는 멱등 연산에만 적용되는가, 서킷 브레이커·백오프·DLQ가 있는가 |
| 성능 | 캐시·배치 크기·커넥션 풀·인덱스·백프레셔가 데이터 규모에 맞는가 |
| 배포 | 롤백 룬북, 카나리/블루그린, 마이그레이션·피처 플래그가 문서화되어 있는가 |
| 용량 | 피크 트래픽·디스크·FD·스레드 풀 상한을 주기적으로 검증하는가 |
스테이징은 데이터 양·네트워크 RTT·동시성을 프로덕션에 가깝게 맞출수록 재현율이 올라갑니다.
확장 예시: 엔드투엔드 미니 시나리오
앞선 본문 주제(「C++ typedef vs using | ‘타입 별칭’ 가이드」)를 배포·운영 흐름에 맞춰 옮긴 체크리스트입니다. 도메인에 맞게 단계 이름만 바꿔 적용할 수 있습니다.
- 입력 계약 고정: 스키마·버전·최대 페이로드·타임아웃·에러 코드를 경계에 둔다.
- 핵심 경로 계측: 요청 ID, 단계별 지연, 외부 호출 결과 코드를 로그·메트릭·트레이스에서 한 흐름으로 본다.
- 실패 주입: 의존성 타임아웃·5xx·부분 데이터·락 대기를 스테이징에서 재현한다.
- 호환·롤백: 설정/마이그레이션/클라이언트 버전을 되돌릴 수 있는지 확인한다.
- 부하 후 검증: 피크 대비 p95/p99, 에러율, 리소스 상한, 알림 임계값을 점검한다.
handle(request):
ctx = newCorrelationId()
validated = validateSchema(request)
authorize(validated, ctx)
result = domainCore(validated)
persistOrEmit(result, idempotentKey)
recordMetrics(ctx, latency, outcome)
return result문제 해결(Troubleshooting)
| 증상 | 가능 원인 | 조치 |
|---|---|---|
| 간헐적 실패 | 레이스, 타임아웃, 외부 의존성, DNS | 최소 재현 스크립트, 분산 트레이스·로그 상관관계, 재시도·서킷 설정 점검 |
| 성능 저하 | N+1, 동기 I/O, 락 경합, 과도한 직렬화, 캐시 미스 | 프로파일러·APM으로 핫스팟 확인 후 한 가지씩 제거 |
| 메모리 증가 | 캐시 무제한, 구독/리스너 누수, 대용량 버퍼, 커넥션 미반납 | 상한·TTL·힙/FD 스냅샷 비교 |
| 빌드·배포만 실패 | 환경 변수, 권한, 플랫폼 차이, lockfile | CI 로그와 로컬 diff, 런타임·이미지 버전 핀 |
| 설정 불일치 | 프로필·시크릿·기본값, 리전 | 스키마 검증된 설정 단일 소스와 배포 매트릭스 표준화 |
| 데이터 불일치 | 비멱등 재시도, 부분 쓰기, 캐시 무효화 누락 | 멱등 키·아웃박스·트랜잭션 경계 재검토 |
권장 순서: (1) 최소 재현 (2) 최근 변경 범위 축소 (3) 환경·의존성 차이 (4) 관측으로 가설 검증 (5) 수정 후 회귀·부하 테스트.
배포 전에는 git add → git commit → git push 후 npm run deploy 순서를 권장합니다.
이 글에서 다루는 키워드 (관련 검색어)
C++, typedef, using, type-alias, C++11 등으로 검색하시면 이 글이 도움이 됩니다.