핵심 요약

std::vector는 원소가 capacity()를 넘으면 더 큰 메모리를 새로 잡고 기존 원소를 옮긴 뒤 이전 메모리를 해제하는 재할당(reallocation)을 수행합니다. 이 재할당이 일어나면 이전 메모리를 가리키던 모든 반복자, 포인터, 참조가 해제된 메모리를 가리키는 댕글링 상태가 되어 vector 반복자 무효화에 따른 정의되지 않은 동작(UB)이 발생합니다. 담을 원소 개수를 미리 안다면 reserve()로 용량을 선확보해 재할당 자체를 막을 수 있습니다.

push_back 몇 번 호출했을 뿐인데 갑자기 크래시가 나거나, 참조해 두었던 값이 이상한 숫자로 바뀌어 있는 경험은 C++을 쓰다 보면 한 번쯤 마주치게 됩니다. 이 글에서는 std::vector의 재할당이 왜 일어나는지, vector 반복자 무효화가 정확히 어떤 현상인지, 그리고 AddressSanitizer로 어떻게 잡아낼 수 있는지를 최소 예제 코드로 정리합니다.

std::vector 재할당이란? size와 capacity의 차이는 무엇인가요?

한 줄 답: 원소가 capacity를 넘으면 vector가 더 큰 메모리를 새로 잡고 원소를 옮긴 뒤 옛 메모리를 해제하는 것입니다.

capacity 4가 꽉 찬 옛 블록에 push_back(5) → 이 실행에서는 capacity 8 새 블록으로 원소를 옮기고 옛 블록 해제, 옛 블록을 가리키던 it는 dangling (UB)

  1. size()와 capacity()의 핵심 차이는 다음과 같습니다. size()는 컨테이너에 현재 실제로 들어 있는 원소의 개수이고, capacity()는 추가적인 메모리 할당 없이 담을 수 있도록 미리 확보해 둔 총 버퍼 칸 수입니다.
  2. 원소 삽입으로 size()가 capacity()를 초과하면 재할당(reallocation)이 일어납니다. 더 큰 연속 메모리 블록을 새로 할당하고, 기존 원소들을 새 메모리로 이전한 뒤 이전 메모리 버퍼를 해제(deallocate)합니다. 기존 메모리가 해제되면서 이전 버퍼를 가리키던 반복자가 무효화되므로, 이 재할당이 바로 vector 반복자 무효화를 일으키는 근본 원인입니다. 이때 성장 배율(growth factor)은 C++ 표준 규격이 아니라 구현 의존(implementation-defined) 사항입니다. 아래 코드는 이 과정을 push_back마다 직접 출력해 확인합니다.
// size와 capacity가 push_back마다 어떻게 바뀌는지 출력합니다 (성장 배율은 구현 의존)
#include <iostream>
#include <vector>

int main() {
    std::vector<int> v;
    const int* old = v.data();
    for (int i = 1; i <= 9; ++i) {
        v.push_back(i);
        bool moved = (v.data() != old);   // 버퍼 주소가 바뀌었으면 재할당
        std::cout << "size=" << v.size() << " capacity=" << v.capacity()
                  << (moved ? "  <- reallocated" : "") << '\n';
        old = v.data();
    }
}

실행 결과 (g++ 14.2.0, libstdc++, x86_64, -std=c++17):

size=1 capacity=1  <- reallocated
size=2 capacity=2  <- reallocated
size=3 capacity=4  <- reallocated
size=4 capacity=4
size=5 capacity=8  <- reallocated
size=6 capacity=8
size=7 capacity=8
size=8 capacity=8
size=9 capacity=16  <- reallocated

이 출력에서 보듯 재할당은 매번 일어나는 것이 아니라 capacity가 부족해지는 특정 지점에서만 발생하며, 늘어나는 폭은 이 libstdc++ 구현의 결과일 뿐 표준이 보장하는 수치가 아닙니다.

  1. 재할당 시 원소를 이전하는 방식은 std::move_if_noexcept로 결정됩니다. 원소 타입의 이동 생성자가 noexcept로 선언되어 있으면 이동(move)을 쓰고, 그렇지 않으면서 복사가 가능한 타입이면 강한 예외 안전성을 지키기 위해 복사(copy)를 씁니다. 이동과 복사가 각각 언제 선택되는지는 복사 생성자 vs 이동 생성자 차이: 언제 무엇이 호출되나?에서 더 자세히 다룹니다.

반복자 무효화란? 어떤 연산 뒤에 포인터·참조가 깨지나요?

한 줄 답: 컨테이너 메모리 재할당이나 원소 삭제·이동으로 인해 기존 반복자, 포인터, 참조가 유효하지 않은 메모리를 가리키게 되어 접근 시 정의되지 않은 동작(UB)을 유발하는 현상입니다.

  1. std::vector는 모든 원소가 단일 연속 메모리에 저장되므로, 재할당이 일어나 기존 버퍼가 해제되면 그 버퍼를 가리키던 모든 포인터, 참조, 반복자가 일제히 해제된 메모리를 가리키는 댕글링(dangling) 상태가 됩니다. 이는 std::map vs std::unordered_map 차이에서 다룬 std::unordered_map의 rehash 시 반복자만 무효화되고 원소 노드 참조는 그대로 유지되는 것과 뚜렷이 대비되는 특징입니다.
  2. cppreference std::vector의 “Iterator invalidation” 규칙을 요약하면 다음과 같습니다.
    • push_back, emplace_back: size()가 기존 capacity()를 초과해 재할당이 발생하면 모든 반복자(end() 포함)와 참조가 무효화됩니다. 재할당이 없으면 end() 반복자만 무효화됩니다.
    • insert, emplace: 재할당이 발생하면 모든 반복자·참조가 무효화됩니다. 재할당이 없으면 삽입 지점 및 그 뒤의 반복자·참조(end() 포함)가 무효화됩니다.
    • erase: 삭제된 원소 및 그 뒤의 모든 반복자·참조(end() 포함)가 무효화됩니다.
    • pop_back: 삭제된 마지막 원소와 end() 반복자가 무효화됩니다.
    • reserve, shrink_to_fit: capacity가 변경된 경우에만 모든 반복자·참조가 무효화되고, 변경되지 않으면 무효화가 없습니다.
    • clear, operator=, assign: 항상 모든 반복자·참조가 무효화됩니다.
    • swap: end() 반복자만 무효화됩니다.
    • 읽기 전용 연산: 반복자 무효화가 없습니다.
  3. 전형적인 버그 패턴 (a): 원소 참조를 잡아 둔 채 push_back을 호출하는 경우입니다. capacity가 꽉 찬 상태에서 push_back으로 재할당이 발생하면 기존 참조 r이 해제된 힙 메모리를 가리키게 됩니다.
// UB 예제: 원소 참조를 잡아 둔 채 push_back -> 재할당 뒤 참조가 해제된 메모리를 가리킴
#include <iostream>
#include <vector>

int main() {
    std::vector<int> v = {1, 2, 3, 4};
    std::cout << "capacity=" << v.capacity() << '\n';
    int& r = v[0];          // 첫 원소 참조
    v.push_back(5);         // capacity 초과 -> 재할당, r은 무효
    std::cout << "r = " << r << '\n';   // UB: 해제된 메모리 읽기
}

실행 결과 [UB: 정의되지 않은 동작, 이 출력은 보장되지 않음]:

capacity=4
r = 1503387104

ASan 실행 발췌 (AddressSanitizer heap-use-after-free 요약):

=================================================================
==PID==ERROR: AddressSanitizer: heap-use-after-free on address 0x502000000010 at pc 0x561225a504b2 bp 0x7ffc435840a0 sp 0x7ffc43584098
READ of size 4 at 0x502000000010 thread T0

이러한 댕글링 메모리 역참조 버그는 AddressSanitizer를 활성화해 두면 실행 즉시 포착할 수 있습니다.

  1. 전형적인 버그 패턴 (b): 순회 도중 push_back을 호출하는 경우입니다. 루프 도중 재할당이 발생하면 순회 중인 반복자 it와 탈출 조건인 v.end()가 모두 무효화됩니다. 이후 동작은 UB라서 크래시가 날 수도, 조용히 이상한 결과가 나올 수도 있습니다.
// UB 예제: 순회 중 push_back -> 반복자 무효화
#include <iostream>
#include <vector>

int main() {
    std::vector<int> v = {1, 2, 3, 4};
    for (auto it = v.begin(); it != v.end(); ++it) {
        if (*it == 2) v.push_back(20);   // 재할당되면 it, end()가 모두 무효
    }
    std::cout << "size=" << v.size() << '\n';
}

실행 결과 [UB: 정의되지 않은 동작, 이 출력은 보장되지 않음]:

size=6

ASan 실행 발췌 (AddressSanitizer heap-use-after-free 요약):

=================================================================
==PID==ERROR: AddressSanitizer: heap-use-after-free on address 0x502000000018 at pc 0x55f17a3b843a bp 0x7ffd151506b0 sp 0x7ffd151506a8
READ of size 4 at 0x502000000018 thread T0

reserve()는 언제 써야 하나요? 면접에서는 어떻게 정리하나요?

한 줄 답: 삽입할 원소 개수를 미리 알 때 불필요한 재할당을 없애 성능을 최적화하고 반복자 무효화를 방지하기 위해 사용합니다.

  1. cppreference reserve에 따르면 new_cap > capacity()인 경우 더 큰 메모리를 할당하며, 이 시점에는 기존 반복자가 무효화됩니다. 하지만 일단 필요한 용량을 확보해 두면 그 범위 안에서는 원소를 계속 추가해도 재할당이 일어나지 않아 반복자·참조가 안전하게 유지됩니다.

    reserve(8) 뒤 push_back(5): 같은 버퍼 안에서 추가되어 재할당이 없고 it는 유효 (*it=1)

  2. reserve()를 잘못 쓰는 예는 push_back을 할 때마다 그 직전에 reserve()를 호출하는 것입니다. cppreference는 이렇게 하면 capacity가 지수적이 아니라 선형으로 늘어나 재할당이 오히려 늘고 성능이 떨어질 수 있다고 설명합니다. 개수를 미리 알 때 한 번 호출하는 것이 좋습니다.

  3. 반복자 무효화를 예방하는 세 가지 안전한 패턴은 다음과 같습니다.

    1. reserve()로 사전 용량을 충분히 확보해 동일 버퍼를 유지하고 반복자를 보존합니다.
    2. 순회 중 동적 추가가 필요할 때는 반복자 대신 인덱스(size_t i) 기반 순회를 사용합니다.
    3. 순회 중 원소를 삭제할 때는 erase()가 반환하는 다음 유효 원소 반복자로 갱신하며 순회합니다.

    아래는 세 패턴을 모두 담은 종합 예제입니다.

// 고친 버전: reserve, 인덱스 순회, erase 반환값 사용
#include <iostream>
#include <vector>

int main() {
    // (1) reserve: 넉넉히 잡아 두면 그 범위 안에서는 재할당이 없음
    std::vector<int> a = {1, 2, 3, 4};
    a.reserve(8);
    const int* before = a.data();
    auto it = a.begin();
    a.push_back(5);
    std::cout << "reserve: same buffer=" << (a.data() == before)
              << " *it=" << *it << '\n';

    // (2) 순회 중 추가: 인덱스로 돌기 (반복자 대신)
    std::vector<int> b = {1, 2, 3, 4};
    for (std::size_t i = 0; i < b.size(); ++i) {
        if (b[i] == 2) b.push_back(20);
    }
    std::cout << "index loop: size=" << b.size() << " last=" << b.back() << '\n';

    // (3) erase: 반환된 반복자로 이어서 순회
    std::vector<int> c = {1, 2, 3, 4, 5, 6};
    for (auto e = c.begin(); e != c.end(); ) {
        if (*e % 2 == 0) e = c.erase(e);
        else ++e;
    }
    std::cout << "erase loop:";
    for (int x : c) std::cout << ' ' << x;
    std::cout << '\n';
}

실행 결과:

reserve: same buffer=1 *it=1
index loop: size=5 last=20
erase loop: 1 3 5
  1. 반복자 무효화는 컴파일 시점에는 경고 없이 넘어가지만, 런타임에 간헐적 이상값이나 크래시를 일으키는 정의되지 않은 동작(UB)입니다. 따라서 컨테이너 크기 변경과 원소 참조의 생명 주기를 명확히 분리해 설계하는 것이 중요합니다.

[시험용/면접 핵심 한 줄] std::vector는 연속 메모리 기반이므로 capacity를 초과하는 push_back 시 새 메모리로 재할당되어 모든 반복자·참조가 일제히 무효화(UB)됩니다. 담을 원소 개수를 미리 안다면 reserve()로 용량을 선확보해 재할당을 방지해야 합니다.

면접 답변 템플릿: “vector는 원소를 연속 메모리에 두기 때문에, push_back으로 size가 capacity를 넘으면 더 큰 메모리로 재할당하고 옛 메모리를 해제합니다. 이때 모든 반복자·포인터·참조가 무효가 되고, 그 뒤에 쓰면 UB입니다. 개수를 알면 reserve로 미리 잡고, 순회 중 추가는 인덱스로, 삭제는 erase의 반환 반복자로 처리합니다.”

이해했는지 Q&A로 확인해 볼까요?

Q1. std::vector에서 size()와 capacity()의 차이는 무엇인가요?

A1. size()는 현재 컨테이너에 실제로 담겨 있는 원소의 개수를 반환하며, capacity()는 메모리 추가 재할당 없이 담을 수 있는 최대 버퍼 용량(확보된 칸 수)을 반환합니다.

Q2. push_back을 호출하면 항상 모든 반복자가 무효화되나요?

A2. 아닙니다. 원소 삽입 후 size()가 기존 capacity()를 초과해 메모리 재할당(reallocation)이 일어날 때만 모든 반복자와 원소 참조가 무효화됩니다. 재할당이 발생하지 않는다면 end() 반복자만 무효화되고, 기존 원소를 가리키는 반복자와 참조는 그대로 유효합니다.

Q3. 루프 순회 중 특정 조건의 원소를 erase()할 때 반복자 무효화를 방지하려면 어떻게 해야 하나요?

A3. erase()는 삭제된 원소와 그 뒤의 모든 반복자를 무효화하므로, it = v.erase(it);처럼 erase()가 반환하는 ‘삭제된 원소의 다음 위치를 가리키는 유효한 반복자’로 갱신하며 순회해야 합니다. erase-remove 관용구나 std::erase 비멤버 함수를 활용하는 것도 안전한 방법입니다.

Q4. push_back을 할 때마다 그 직전에 reserve()를 호출하면 어떻게 되나요?

A4. capacity가 지수적이 아니라 선형으로 늘어나 재할당이 오히려 늘고 성능이 떨어질 수 있습니다(cppreference reserve 설명). 담을 개수를 미리 알 때 한 번 호출하는 것이 좋습니다.