C++ size_t와 ptrdiff_t: 부호 없는 인덱스 함정과 std::ssize·cmp_less

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

“64비트면 unsigned long”이라는 설명은 리눅스·macOS(LP64 모델)에서만 맞습니다. 64비트 Windows는 LLP64 모델이라 long이 여전히 32비트이고, size_t는 unsigned long long입니다. 그래서 unsigned long n = vec.size();처럼 쓴 코드는 리눅스에서 멀쩡하다가 MSVC에서 C4267: conversion from 'size_t' to 'unsigned long', possible loss of data 경고를 내고, 실제로 40억 개가 넘는 원소에서 값이 잘립니다. printf로 출력할 때도 %lu는 Windows에서 틀린 서식이 되므로, size_t 전용 서식인 %zu를 쓰거나 std::cout을 쓰는 것이 이식성 있는 방법입니다. 이런 차이 때문에 크기를 담는 변수는 long 같은 기본 타입이 아니라 size_t 별칭 그대로 쓰는 것이 원칙입니다.

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

포인터 뺄셈에는 두 가지 조건이 붙습니다. 첫째, 두 포인터가 같은 배열(또는 그 끝 바로 다음)을 가리켜야 합니다. 서로 다른 malloc 블록이나 다른 변수를 가리키는 포인터끼리 빼는 것은 미정의 동작이라, 결과가 그럴듯한 숫자로 나와도 의미가 없습니다. 둘째, ptrdiff_t는 부호 비트를 쓰므로 표현 범위가 size_t의 절반입니다. 32비트 시스템에서 2GB를 넘는 char 배열의 양 끝을 빼면 결과가 PTRDIFF_MAX를 넘어 오버플로가 날 수 있습니다. 64비트에서는 현실적으로 만나기 어렵지만, 크기와 차이를 서로 다른 타입으로 둔 이유가 이 범위 차이에 있다는 점은 알아 둘 만합니다.

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

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를 고려합니다.
• 비교 자체를 안전하게 하려면 C++20의 std::cmp_less(i, n)(<utility>)을 씁니다. 이 함수는 부호가 다른 정수를 수학적인 값 그대로 비교해 std::cmp_less(-1, size_t{10})이 true가 됩니다. 캐스팅 조건을 직접 쓰는 것보다 실수할 여지가 적습니다.

이 문제가 C++에서 오래 논쟁거리인 이유는 표준 라이브러리 설계 자체에 있습니다. 컨테이너의 size()가 부호 없는 타입을 돌려주기로 정해진 탓에, 인덱스 계산에 조금이라도 뺄셈이 들어가면 부호 없는 래핑 위험이 따라옵니다. C++ Core Guidelines는 인덱스와 크기 계산에 부호 있는 타입(gsl::index, 즉 ptrdiff_t)을 권하고, Bjarne Stroustrup도 size()를 부호 없는 타입으로 정한 것을 실수로 언급한 적이 있습니다. 부호 있는 타입은 오버플로가 미정의 동작이라는 위험이 있지만, 그 덕분에 컴파일러가 “인덱스는 계속 증가한다”고 가정하고 루프를 더 잘 최적화할 수 있다는 장점도 있습니다. 어느 쪽을 택하든 한 코드베이스 안에서는 통일하는 것이 경고와 캐스팅을 줄이는 가장 현실적인 방법입니다.

루프에서의 활용

• 전진 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) {
    // ...
}

// ✅ C++20: 부호가 달라도 수학적으로 비교
if (std::cmp_less(i, size)) {
    // ...
}

-Wsign-compare는 GCC에서는 C++ 코드에 대해 -Wall에, Clang에서는 -Wextra에 포함되어 있어 comparison of integer expressions of different signedness: 'int' and 'size_t' 경고가 나옵니다. 이 경고를 static_cast<size_t>(i) < size로 캐스팅만 해서 없애는 것이 흔한 실수입니다. 경고는 사라지지만 i가 음수일 때 여전히 큰 양수로 바뀌어 비교가 틀리므로, 버그를 숨기기만 한 셈이 됩니다. 캐스팅하기 전에 “이 값이 음수가 될 수 있는가”를 먼저 따져야 합니다.

문제 2: 언더플로우

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

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

부호 없는 정수의 래핑은 표준이 정의한 동작(2ⁿ으로 나눈 나머지)이라 컴파일러도 새니타이저도 기본 설정으로는 잡아 주지 않습니다. 부호 있는 정수 오버플로는 -fsanitize=undefined가 잡아 주지만, size_t가 0 아래로 내려가는 것은 “정상 동작”이기 때문입니다. Clang의 -fsanitize=unsigned-integer-overflow를 켜면 이런 래핑도 런타임에 보고받을 수 있는데, 해시 함수처럼 의도적으로 래핑을 쓰는 코드에서도 보고가 나오므로 테스트 빌드에서만 켜 두는 편이 좋습니다. 가장 흔한 형태는 size_t remaining = total - used;에서 used가 total보다 커지는 경우로, 음수가 되어야 할 값이 수백경이 되어 이후 reserve(remaining)이 std::length_error나 메모리 부족으로 터집니다.

문제 3: 루프 역순

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

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

// ✅ 부호 있는 타입 (C++20 std::ssize로 부호 있는 크기를 먼저 얻음)
for (std::ptrdiff_t i = std::ssize(vec) - 1; i >= 0; i--) {
    // ...
}

// ✅ size_t를 유지하는 관용구: 비교 후 감소
for (size_t i = vec.size(); i-- > 0; ) {
    // i는 size()-1부터 0까지
}

원래 흔히 쓰이던 for (int i = vec.size() - 1; ...)에는 숨은 문제가 있습니다. vec이 비어 있으면 vec.size() - 1이 부호 없는 연산이라 SIZE_MAX가 되고, 그 값을 int로 바꾸면 대부분의 구현에서 -1이 되어 루프가 우연히 한 번도 돌지 않을 뿐입니다. 또 원소가 INT_MAX를 넘는 컨테이너에서는 시작 값부터 잘립니다. i-- > 0 관용구는 비교를 먼저 하고 감소시키므로 i가 0일 때 조건이 거짓이 되어 래핑된 값을 쓰기 전에 루프를 빠져나옵니다. 코드 리뷰에서 처음 보면 헷갈리는 모양이라 주석을 달아 두는 편이 좋습니다. 가장 흔한 버그는 이런 역순 루프가 아니라 for (size_t i = 0; i < vec.size() - 1; ++i)처럼 “마지막 하나 전까지” 도는 루프입니다. 빈 벡터에서 vec.size() - 1이 거대한 값이 되어 범위 밖 접근으로 크래시가 납니다. i + 1 < vec.size()로 바꿔 쓰면 뺄셈 자체가 사라집니다.

문제 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: 타입 최댓값·최솟값·NaN 조회와 오버플로우 검사
• C++ 반복자
• C++ std::vector 기초
• 배열과 연결 리스트

---