C++ size_t & ptrdiff_t | "크기 타입" 가이드

size_t란?

size_t 는 부호 없는 정수 타입으로, 객체의 크기나 배열 인덱스를 표현하는 데 사용됩니다. sizeof 연산자의 반환 타입이며, 플랫폼에 따라 크기가 달라집니다.

size_t length = str.length();
size_t size = vec.size();

// 플랫폼별 크기
// 32비트: 4바이트 (0 ~ 4,294,967,295)
// 64비트: 8바이트 (0 ~ 18,446,744,073,709,551,615)

왜 필요한가?:

• 플랫폼 독립성: 플랫폼에 맞는 최대 크기 표현
• 타입 안전: 크기와 인덱스에 적합한 타입
• 표준 호환: STL 컨테이너와 일관성

// ❌ int: 플랫폼 독립적이지 않음
int size = vec.size();  // 64비트에서 경고

// ✅ size_t: 플랫폼 독립적
size_t size = vec.size();

size_t의 정의:

// <cstddef>에 정의됨
// 일반적으로:
// 32비트: typedef unsigned int size_t;
// 64비트: typedef unsigned long size_t; (또는 unsigned long long)

#include <cstddef>
#include <iostream>

int main() {
    std::cout << "size_t 크기: " << sizeof(size_t) << "바이트\n";
    std::cout << "size_t 최대값: " << SIZE_MAX << '\n';
}

ptrdiff_t란?

ptrdiff_t 는 부호 있는 정수 타입으로, 두 포인터 간의 차이를 표현하는 데 사용됩니다. 포인터 뺄셈의 결과 타입이며, 음수 값도 표현할 수 있습니다.

int arr[10];
int* p1 = &arr[0];
int* p2 = &arr[5];

ptrdiff_t diff = p2 - p1;  // 5

왜 필요한가?:

• 부호: 포인터 차이는 음수일 수 있음
• 플랫폼 독립성: 포인터 크기에 맞는 타입
• 표준 호환: std::distance의 반환 타입

int arr[10];
int* p1 = &arr[7];
int* p2 = &arr[3];

ptrdiff_t diff = p2 - p1;  // -4 (음수)

// ❌ size_t: 부호 없음
// size_t diff2 = p2 - p1;  // 큰 양수로 변환됨

ptrdiff_t의 정의:

// <cstddef>에 정의됨
// 일반적으로:
// 32비트: typedef int ptrdiff_t;
// 64비트: typedef long ptrdiff_t; (또는 long long)

#include <cstddef>
#include <iostream>

int main() {
    std::cout << "ptrdiff_t 크기: " << sizeof(ptrdiff_t) << "바이트\n";
    std::cout << "ptrdiff_t 최대값: " << PTRDIFF_MAX << '\n';
    std::cout << "ptrdiff_t 최소값: " << PTRDIFF_MIN << '\n';
}

부호 있는 타입과 부호 없는 타입 혼합

C++에서 int 같은 부호 있는 값과 size_t 같은 부호 없는 값을 비교하면, 보통 부호 있는 쪽이 더 넓은 부호 없는 타입으로 변환됩니다. 그래서 int i = -1과 size_t n = 10일 때 i < n이 거짓이 되는 등 직관과 어긋날 수 있습니다.

• 인덱스가 음수일 수 없다는 전제면: static_cast<size_t>(i) 전에 i >= 0을 검사합니다.
• 차이를 다룰 때는 가능하면 ptrdiff_t 또는 C++20의 std::ssize(예: <iterator> 경로)처럼 부호 있는 크기를 명시적으로 쓰는 API를 고려합니다.

루프에서의 활용

• 전진 for: for (size_t i = 0; i < vec.size(); ++i)가 가장 흔합니다. vec.size()가 size_t이므로 i도 size_t로 맞추면 경고가 사라집니다.
• 역방향: size_t i = vec.size() - 1; i >= 0; i--는 i가 항상 부호 없이 ≥0이라 무한 루프가 됩니다. 역방향은 for (auto it = vec.rbegin(); it != vec.rend(); ++it) 또는 부호 있는 ptrdiff_t/int 인덱스를 쓰세요.
• 범위 기반 for: 인덱스가 필요 없으면 for (auto& x : vec)가 가장 안전합니다.

차이 계산에 ptrdiff_t 쓰기

같은 배열 객체 안의 두 포인터 뺄셈 결과 타입은 ptrdiff_t입니다. 반복자에 대해서는 std::distance가 임의 접근이면 상수 시간이고, 그 반환 타입도 보통 ptrdiff_t에 대응합니다.

std::vector<int> v = {1,2,3,4,5};
auto d = std::distance(v.begin(), v.begin() + 3);  // ptrdiff_t에 대응하는 타입

두 스팬(span)이 같은 배열을 가리킬 때 길이 차를 다루는 코드에서는, 음수가 나올 수 있으면 **ptrdiff_t**로 받는 편이 명확합니다.

실전 패턴 보강

• ssize_t(POSIX): read/write 등은 반환을 ssize_t로 두어 오류는 음수로 표현합니다. 순수 C++ 표준만 쓰는 코드에서는 std::ptrdiff_t/std::int64_t 등으로 팀 규칙을 통일하세요.
• 서로 다른 컨테이너 크기 비교: 둘 다 size_t로 받고, 뺄 때만 ptrdiff_t로 캐스팅할지, 아니면 안전한 보조 함수로 최소·최대를 구할지 정합니다.
• 고정폭 프로토콜: 파일·패킷 크기는 uint32_t 등 고정 폭 부호 없는 정수로 명시하면 size_t와의 혼동이 줄어듭니다.

이식성과 컴파일러 경고

• size_t의 정확한 별칭(unsigned long vs unsigned long long)은 플랫폼마다 다를 수 있지만, sizeof/size()와 함께 쓰는 한 표준 라이브러리와 일관됩니다.
• 64비트에서 size_t는 보통 64비트입니다. 32비트 호환을 신경 쓰면, 디스크에 쓰는 크기는 uint64_t로 고정하는 식으로 직렬화 규격을 분리하세요.
• 경고 레벨: -Wsign-compare(GCC/Clang) 등을 켜 두면 int vs size_t 비교를 조기에 잡을 수 있습니다.

실전 예시

예시 1: 컨테이너 순회

#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    
    // ✅ size_t 사용
    for (size_t i = 0; i < vec.size(); i++) {
        std::cout << vec[i] << " ";
    }
    
    // ❌ int 사용 (경고)
    for (int i = 0; i < vec.size(); i++) {
        // 부호 비교 경고
    }
}

예시 2: 배열 크기

void processArray(int* arr, size_t size) {
    for (size_t i = 0; i < size; i++) {
        arr[i] *= 2;
    }
}

int main() {
    int arr[100];
    processArray(arr, sizeof(arr) / sizeof(arr[0]));
}

예시 3: 포인터 연산

int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

int* begin = arr;
int* end = arr + 10;

ptrdiff_t size = end - begin;  // 10
std::cout << "크기: " << size << std::endl;

// 거리 계산
int* p = arr + 5;
ptrdiff_t dist = p - begin;  // 5

예시 4: std::distance

#include <vector>
#include <iterator>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    
    auto it1 = vec.begin();
    auto it2 = vec.end();
    
    ptrdiff_t dist = std::distance(it1, it2);  // 5
}

자주 발생하는 문제

문제 1: 부호 비교

// ❌ 부호 비교 경고
int i = -1;
size_t size = 10;

if (i < size) {  // 경고: i가 큰 양수로 변환
    // ...
}

// ✅ 명시적 캐스팅
if (i >= 0 && static_cast<size_t>(i) < size) {
    // ...
}

문제 2: 언더플로우

// ❌ 언더플로우
size_t i = 0;
i--;  // 큰 양수 (언더플로우)

// ✅ 체크
if (i > 0) {
    i--;
}

문제 3: 루프 역순

// ❌ 무한 루프
for (size_t i = vec.size() - 1; i >= 0; i--) {
    // i는 항상 >= 0
}

// ✅ 역방향 반복자
for (auto it = vec.rbegin(); it != vec.rend(); ++it) {
    // ...
}

// ✅ 부호 있는 타입
for (int i = vec.size() - 1; i >= 0; i--) {
    // ...
}

문제 4: 포인터 차이 부호

int arr[10];
int* p1 = &arr[5];
int* p2 = &arr[2];

ptrdiff_t diff = p1 - p2;  // 3
ptrdiff_t diff2 = p2 - p1; // -3 (음수 가능)

타입 선택 가이드

// size_t: 크기, 인덱스
size_t length = str.length();
size_t count = vec.size();

// ptrdiff_t: 포인터 차이
ptrdiff_t diff = ptr2 - ptr1;

// ssize_t: 부호 있는 크기 (POSIX)
ssize_t result = read(fd, buffer, size);

타입 선택 비교표:

타입	부호	용도	예시
size_t	없음	크기, 인덱스	vec.size(), sizeof()
ptrdiff_t	있음	포인터 차이	ptr2 - ptr1, std::distance()
int	있음	일반 정수	카운터, 플래그
ssize_t	있음	부호 있는 크기 (POSIX)	read(), write()

실무 선택 가이드:

// ✅ size_t: 크기와 인덱스
std::vector<int> vec(100);
for (size_t i = 0; i < vec.size(); ++i) {
    vec[i] = i;
}

// ✅ ptrdiff_t: 포인터 차이
int arr[10];
int* begin = arr;
int* end = arr + 10;
ptrdiff_t size = end - begin;

// ✅ int: 일반 카운터 (음수 가능)
int counter = 0;
for (int i = -5; i <= 5; ++i) {
    counter++;
}

// ❌ size_t: 음수 불가
// size_t i = -1;  // 큰 양수로 변환됨

size_t vs int 선택 기준:

상황	권장 타입	이유
컨테이너 크기	size_t	size() 반환 타입
배열 인덱스	size_t	크기와 일관성
음수 필요	int	size_t는 부호 없음
작은 범위	int	간단함
역방향 루프	int 또는 역방향 반복자	size_t는 언더플로우 위험

실무 패턴

패턴 1: 안전한 인덱스 접근

template<typename T>
std::optional<T> safeGet(const std::vector<T>& vec, size_t index) {
    if (index < vec.size()) {
        return vec[index];
    }
    return std::nullopt;
}

// 사용
auto value = safeGet(vec, 10);
if (value) {
    std::cout << *value << '\n';
}

패턴 2: 범위 검증

bool isValidRange(const std::vector<int>& vec, size_t start, size_t end) {
    return start <= end && end <= vec.size();
}

// 사용
if (isValidRange(vec, 0, 10)) {
    // 안전한 범위
}

패턴 3: 포인터 범위 계산

template<typename T>
ptrdiff_t countInRange(const T* begin, const T* end, const T& value) {
    ptrdiff_t count = 0;
    for (const T* p = begin; p != end; ++p) {
        if (*p == value) {
            ++count;
        }
    }
    return count;
}

// 사용
int arr[] = {1, 2, 3, 2, 1};
ptrdiff_t count = countInRange(arr, arr + 5, 2);  // 2

FAQ

Q1: size_t는 언제 사용해야 하나요?

A:

• 객체의 크기 (sizeof 결과)
• 배열 인덱스 및 크기
• 컨테이너 크기 (vec.size())
• 메모리 할당 크기

size_t length = str.length();
size_t size = vec.size();
size_t bytes = sizeof(int);

Q2: ptrdiff_t는 언제 사용해야 하나요?

A: 포인터 간의 차이를 계산할 때 사용합니다. std::distance()의 반환 타입이기도 합니다.

int arr[10];
ptrdiff_t diff = &arr[5] - &arr[2];  // 3

std::vector<int> vec = {1, 2, 3};
ptrdiff_t dist = std::distance(vec.begin(), vec.end());  // 3

Q3: int 대신 size_t를 사용해야 하나요?

A:

• 크기와 인덱스: size_t 권장 (컨테이너와 일관성)
• 음수가 필요한 경우: int 사용
• 작은 범위: int로도 충분

// ✅ size_t: 크기와 인덱스
for (size_t i = 0; i < vec.size(); ++i) { }

// ✅ int: 음수 필요
for (int i = -10; i <= 10; ++i) { }

Q4: size_t 언더플로우 주의사항은?

A: size_t는 부호 없는 타입이므로 0에서 감소하면 큰 양수로 변환됩니다.

// ❌ 언더플로우
size_t i = 0;
i--;  // 18,446,744,073,709,551,615 (64비트)

// ✅ 체크
if (i > 0) {
    i--;
}

// ✅ 역방향 반복자
for (auto it = vec.rbegin(); it != vec.rend(); ++it) { }

Q5: 플랫폼별 크기는?

A:

• 32비트: size_t는 4바이트 (0 ~ 4,294,967,295)
• 64비트: size_t는 8바이트 (0 ~ 18,446,744,073,709,551,615)

#include <cstddef>
#include <iostream>

int main() {
    std::cout << "size_t: " << sizeof(size_t) << "바이트\n";
    std::cout << "ptrdiff_t: " << sizeof(ptrdiff_t) << "바이트\n";
}

Q6: 부호 있는 타입과 부호 없는 타입을 비교할 때 주의사항은?

A: 부호 있는 타입이 부호 없는 타입으로 변환되어 예상치 못한 결과가 발생할 수 있습니다.

int i = -1;
size_t size = 10;

// ❌ i가 큰 양수로 변환됨
if (i < size) {  // 항상 false (i는 큰 양수)
    // ...
}

// ✅ 명시적 체크
if (i >= 0 && static_cast<size_t>(i) < size) {
    // ...
}

Q7: size_t 학습 리소스는?

A:

• “C++ Primer” (5th Edition) by Stanley Lippman
• “Effective C++” (3rd Edition) by Scott Meyers
• cppreference.com - size_t
• cppreference.com - ptrdiff_t

관련 글: Numeric Limits, Iterator Guide, STL Vector.

한 줄 요약: size_t는 크기와 인덱스에, ptrdiff_t는 포인터 차이에 사용하는 플랫폼 독립적인 타입입니다.

---

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

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

• C++ numeric_limits | “타입 한계” 가이드
• C++ 반복자 | “Iterator” 완벽 가이드
• C++ STL vector | “배열보다 편한” 벡터 완벽 정리 [실전 예제]

관련 글

• 배열과 리스트 | 코딩 테스트 필수 자료구조 완벽 정리
• C++ Adapter Pattern 완벽 가이드 | 인터페이스 변환과 호환성
• C++ ADL |
• C++ Aggregate Initialization |
• C++ Aggregate Initialization 완벽 가이드 | 집합 초기화