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)

size_t는 그 플랫폼에서 만들 수 있는 가장 큰 객체의 크기를 담을 수 있도록 정의되므로, 크기와 인덱스를 담는 데 플랫폼과 무관하게 쓸 수 있습니다. 표준 컨테이너의 size()도 (size_type을 통해) 보통 size_t를 돌려주므로, 같은 타입을 쓰면 변환 경고 없이 일관되게 다룰 수 있습니다.

// int: 64비트에서 20억 개가 넘는 크기를 담지 못함
int size = vec.size();  // -Wconversion 등에서 축소 변환 경고

// 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

포인터 차이는 뒤쪽 포인터에서 앞쪽 포인터를 빼면 음수가 될 수 있으므로 부호 있는 타입이어야 하고, 같은 배열 안의 어떤 두 위치의 차이도 담을 수 있도록 플랫폼의 포인터 폭에 맞춰 정의됩니다. 표준 컨테이너 반복자의 difference_type과 std::distance의 반환 타입도 보통 ptrdiff_t입니다.

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은 거짓이 됩니다. -1이 SIZE_MAX로 바뀐 뒤 비교되기 때문입니다.

인덱스가 음수일 수 없다는 전제라면 static_cast<size_t>(i)로 바꾸기 전에 i >= 0을 먼저 검사합니다. 차이를 계산해야 한다면 처음부터 ptrdiff_t나 C++20의 std::ssize(부호 있는 크기를 돌려주는 <iterator>의 함수)로 부호 있는 값을 다루는 편이 낫습니다. 비교 자체를 안전하게 하려면 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도 P1428(“Subscripts and sizes should be signed”)에서 같은 주장을 했습니다. 부호 있는 타입은 오버플로가 미정의 동작이라는 위험이 있지만, 그 덕분에 컴파일러가 “인덱스는 래핑되지 않는다”고 가정하고 루프를 더 잘 최적화할 수 있다는 장점도 있습니다. 어느 쪽을 택하든 한 코드베이스 안에서는 통일하는 것이 경고와 캐스팅을 줄이는 가장 현실적인 방법입니다.

루프에서의 활용

전진 루프는 for (size_t i = 0; i < vec.size(); ++i)가 가장 흔합니다. vec.size()가 size_t이므로 i도 size_t로 맞추면 부호 비교 경고가 사라집니다. 인덱스가 필요 없다면 for (auto& x : vec) 범위 기반 for가 가장 안전합니다. 역방향 루프는 주의해야 합니다. for (size_t i = vec.size() - 1; i >= 0; i--)는 i가 부호 없는 타입이라 i >= 0이 항상 참이므로 무한 루프가 됩니다(아래 문제 3). 역방향은 rbegin()/rend() 반복자를 쓰거나, 부호 있는 인덱스를 쓰거나, i-- > 0 관용구를 씁니다.

차이 계산에 ptrdiff_t 쓰기

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

std::vector<int> v = {1,2,3,4,5};
auto d = std::distance(v.begin(), v.begin() + 3);  // std::vector<int>::difference_type, 값 3

두 스팬(span)의 길이 차처럼 음수가 나올 수 있는 값은 처음부터 ptrdiff_t로 받는 편이 명확합니다.

그 밖의 크기 타입

POSIX의 read/write는 반환 타입을 ssize_t로 두어 읽은 바이트 수와 오류(-1)를 한 값으로 돌려줍니다. 표준 C++에는 ssize_t가 없으므로, POSIX 바깥 코드에서 같은 용도가 필요하면 std::ptrdiff_t나 std::int64_t 중 하나로 팀 규칙을 정합니다. 파일 형식이나 네트워크 패킷에 기록하는 크기는 플랫폼마다 폭이 달라지는 size_t 대신 uint32_t, uint64_t 같은 고정 폭 타입으로 명시해야, 32비트와 64비트 빌드가 같은 파일을 읽을 수 있습니다.

이식성과 컴파일러 경고

size_t의 실제 정의(unsigned long 또는 unsigned long long)는 플랫폼마다 다르지만, sizeof와 컨테이너 size()가 돌려주는 타입과는 항상 일치합니다. 64비트 플랫폼에서 size_t는 보통 64비트이지만 표준이 보장하는 것은 아니며, 예를 들어 x86-64의 x32 ABI는 64비트 CPU에서 32비트 포인터와 32비트 size_t를 씁니다. GCC/Clang의 -Wsign-compare, 그리고 더 엄격한 -Wconversion/-Wsign-conversion을 켜 두면 int와 size_t가 섞이는 지점을 컴파일 단계에서 찾을 수 있습니다.

실전 예시

예시 1: 컨테이너 순회

#include <iostream>
#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	없음	크기, 인덱스	vec.size(), sizeof()
ptrdiff_t	있음	포인터 차이	ptr2 - ptr1, std::distance()
int	있음	일반 정수	카운터, 플래그
ssize_t	있음	부호 있는 크기 (POSIX)	read(), write()

상황별로는 다음과 같이 고를 수 있습니다.

상황	권장 타입	이유
컨테이너 크기	size_t	size() 반환 타입
배열 인덱스	size_t	크기와 일관성
음수 필요	int	size_t는 부호 없음
작은 범위	int	간단함
역방향 루프	역방향 반복자, std::ssize로 얻은 ptrdiff_t, 또는 i-- > 0 관용구	size_t는 i >= 0 조건이 항상 참

실무 패턴

패턴 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

참고 자료

• cppreference: std::size_t
• cppreference: std::ptrdiff_t

---

같이 보면 좋은 글

• C++ numeric_limits: 타입 최댓값·최솟값·NaN 조회와 오버플로우 검사
• C++ 반복자
• C++ std::vector 기초

---

• C++ 문법 선택 기준: 직접 실행으로 확인