동적 메모리 할당

지역 변수는 선언한 블록이 끝나면 사라지고, 배열의 크기는 컴파일할 때 정해야 했습니다. 하지만 입력을 받아야 원소 수를 알 수 있거나, 만든 객체를 함수 밖에서도 계속 써야 할 때가 있습니다. 이럴 때 new 표현식으로 실행 중에 객체를 만들면, 그 객체는 블록과 상관없이 직접 없앨 때까지 남습니다. 이런 객체는 동적 저장 기간(dynamic storage duration)을 가지며, 흔히 힙(heap)에 만든다고 말합니다. 힙 메모리를 할당기와 운영체제가 어떻게 나누어 주는지는 스와핑과 동적 메모리에서 다룹니다.

동적 메모리에서 중요한 것은 주소 자체가 아니라, 누가 그 객체를 소유하고 언제 정리하는지입니다. 포인터 변수가 사라지거나 nullptr을 대입해도 가리키던 객체는 사라지지 않습니다. 이 글은 new와 delete의 규칙, 수동 관리가 실패하는 경로, 그리고 현대 C++이 기본으로 쓰는 std::vector와 std::unique_ptr를 다룹니다.

new와 delete

new 표현식은 저장 공간을 얻고, 그곳에 객체를 초기화한 뒤, 그 객체를 가리키는 포인터를 돌려줍니다. 다 쓴 객체는 delete로 없애며, 배열로 만든 것은 delete[]로 없앱니다.

#include <cstddef>
#include <iostream>

int main() {
    int* value = new int{42};
    std::cout << *value << '\n';
    delete value;
    value = nullptr;

    std::size_t count = 3;
    int* values = new int[count]{10, 20, 30};
    std::cout << values[1] << '\n';
    delete[] values;
    values = nullptr;
}

42
20

new int{42}는 값이 42인 int 하나를 만들고, new int[count]는 실행 중에 정한 개수의 int 배열을 만듭니다. 내장 배열과 달리 count가 상수가 아니어도 됩니다. 아래 그림처럼 단일 객체는 delete, 배열은 delete[]와 짝을 이루며, 어느 쪽을 쓸지는 포인터의 타입이 아니라 그 객체를 만든 new의 형태로 정합니다.

delete는 객체의 수명을 끝내고 그 저장 공간을 돌려줍니다. 초깃값을 주지 않은 new int는 값이 정해지지 않은 int를 만들고, new int{}나 new int()는 0으로 초기화합니다. nullptr에 delete를 적용하면 아무 일도 일어나지 않으므로, 해제 전에 널 검사를 따로 할 필요는 없습니다.

더 깊이: new 표현식이 실제로 하는 일

new 표현식은 두 단계로 이루어집니다. 먼저 할당 함수(allocation function)인 operator new를, 배열이면 operator new[]를 불러 저장 공간을 얻고, 그 공간에 객체를 초기화합니다. delete는 반대로 소멸자를 실행한 뒤 operator delete로 공간을 돌려줍니다. 전역 operator new와 operator delete는 프로그램이 직접 정의해 바꿀 수 있는 대체 가능한(replaceable) 함수여서, 할당을 세거나 기록하는 도구가 이 지점을 씁니다.

배열을 만들 때는 원소들이 차지하는 크기보다 공간을 더 얻을 수 있습니다. 많은 구현이 이 여분에 원소 개수를 저장해 두었다가, delete[]가 소멸자를 몇 번 실행할지 아는 데 씁니다. GCC와 Clang이 따르는 Itanium C++ ABI는 원소 타입에 사소하지 않은(non-trivial) 소멸자가 있으면 배열 앞에 원소 수를 담은 쿠키(cookie)를 두도록 정합니다. 그래서 new[]로 만든 배열을 delete로 해제하면 실제로 할당받은 시작 주소가 아닌 곳을 돌려주게 될 수 있으며, 이것이 짝 불일치가 정의되지 않은 동작인 이유 가운데 하나입니다.

C++14부터는 컴파일러가 new 표현식의 할당을 없애거나 합칠 수 있습니다. 예를 들어 delete[] new int[10];처럼 결과를 쓰지 않는 할당은 통째로 지울 수 있지만, 할당 함수를 직접 부른 operator delete(operator new(10));은 지울 수 없습니다. 그래서 대체한 operator new가 불린 횟수가 소스에 적힌 new의 개수와 다를 수 있습니다.

할당 실패는 예외로 알립니다

일반 new는 저장 공간을 얻지 못하면 nullptr을 돌려주지 않고 std::bad_alloc 예외를 던집니다. 그래서 new의 결과를 nullptr과 비교하는 코드는 할당 실패를 처리하지 못합니다. 실패하면 nullptr을 돌려받아야 하는 특수한 코드에서만 <new>의 new (std::nothrow) int처럼 따로 지정합니다.

#include <cstddef>
#include <iostream>
#include <memory>
#include <new>

int main() {
    const std::size_t count = 1'000;
    try {
        auto values = std::make_unique<int[]>(count);
        values[0] = 42;
        std::cout << values[0] << '\n';
    } catch (const std::bad_alloc& error) {
        std::cerr << "allocation failed: " << error.what() << '\n';
        return 1;
    }
}

std::make_unique<int[]>(count)는 안에서 new int[count]()로 0으로 초기화한 배열을 만들므로, 할당에 실패하면 이 호출에서 std::bad_alloc이 던져집니다. 정상적으로 할당되면 42를 출력합니다. try와 catch는 예외를 잡는 문법으로, try-catch 구문에서 자세히 다룹니다. 할당에 실패해도 그 자리에서 복구할 방법이 없다면, 예외를 잡지 않고 위쪽으로 전달해 프로그램 전체의 오류 처리 방식에 맡기는 편이 낫습니다.

잘못된 해제는 정의되지 않은 동작입니다

delete를 잘못 쓰면 정의되지 않은 동작이 되며, 바로 충돌하지 않고 한참 뒤에 엉뚱한 곳에서 문제가 드러나기도 합니다. 다음은 대표적인 실수입니다.

마지막의 메모리 누수(memory leak)는 정의되지 않은 동작은 아니지만, 오래 실행되는 프로그램에서는 쓸 수 있는 메모리가 점점 줄어듭니다. 프로그램이 끝나면 운영체제가 메모리를 돌려받지만, 그 전까지는 아무도 그 객체를 없앨 수 없습니다.

nullptr은 포인터 하나만 바꿉니다

여러 포인터가 같은 객체를 가리킬 수 있습니다. 한 포인터로 객체를 해제하고 그 포인터에 nullptr을 대입해도, 다른 포인터는 해제된 주소를 그대로 들고 있습니다.

int* owner = new int{7};
int* alias = owner;  // 같은 객체를 가리킴

delete owner;        // 객체의 수명이 끝남
owner = nullptr;     // owner만 nullptr이 됨

// *alias = 9;       // 해제 뒤 사용: 정의되지 않은 동작
// delete alias;     // 이중 해제: 정의되지 않은 동작
alias = nullptr;     // alias도 따로 정리해야 함

해제한 뒤 포인터에 nullptr을 대입하는 습관은 같은 변수를 실수로 다시 쓰는 일을 줄여 주지만, 다른 별칭까지 고쳐 주지는 않습니다. 근본적인 해결은 객체를 소유하는 것을 하나로 정하고, 소유하지 않는 포인터가 소유자보다 오래 남지 않게 구조를 짜는 것입니다.

수동 관리가 실패하는 경로

수동으로 관리하는 코드는 정상 경로보다 조기 반환이나 예외 경로에서 더 쉽게 깨집니다. 아래 함수는 new로 만든 객체를 함수 끝에서 delete하도록 짜여 있지만, 그 사이에 함수를 빠져나가는 return이 하나 있습니다. 원인을 읽기 위한 조각이어서 main 없이 함수만 보입니다.

void process(bool stopEarly) {
    int* value = new int{42};

    if (stopEarly) {
        return; // delete를 건너뛰어 누수
    }

    delete value;
}

stopEarly가 참이면 delete에 도달하지 않고 함수가 끝나, value가 가리키던 객체를 해제할 방법이 사라집니다. 분기마다 delete를 복사해 넣으면 이 예는 고칠 수 있지만, 나중에 분기를 추가하거나 중간에 예외가 던져지면 다시 빠뜨리기 쉽습니다. 앞의 goto 문에서 본 것처럼, 해제 호출을 점프나 반환이 건너뛰는 문제입니다.

RAII: 소유자에게 정리를 맡기기

현대 C++은 이 문제를 자원을 객체에 묶는 RAII(Resource Acquisition Is Initialization)로 해결합니다. 자원을 소유하는 객체는 블록을 벗어나면 정상 반환이든 예외든 자동으로 정리되므로, 그 객체가 자원도 함께 해제하게 만드는 것입니다. 표준 라이브러리의 std::vector, std::string, std::unique_ptr가 이런 소유자입니다.

#include <cstddef>
#include <iostream>
#include <memory>
#include <vector>

void process(std::size_t count, bool stopEarly) {
    std::vector<int> values(count);
    auto answer = std::make_unique<int>(42);

    if (stopEarly || values.empty()) {
        std::cout << "skip\n";
        return;
    }
    values.front() = *answer;
    std::cout << values.size() << ' ' << values.front() << '\n';
}

int main() {
    process(3, false);
    process(0, false);
    process(3, true);
}

3 42
skip
skip

std::vector<int> values(count)는 실행 중에 정한 개수의 int를 0으로 만들어 소유하고, std::make_unique<int>(42)는 값이 42인 int를 만들어 그것을 소유하는 std::unique_ptr를 돌려줍니다. auto는 초깃값의 타입으로 변수의 타입을 정하는 문법입니다. 아래 그림처럼 첫 호출은 값을 복사해 3 42를 출력하고, 원소가 없는 둘째 호출과 조기 반환하는 셋째 호출은 skip을 출력하며, 세 경우 모두 함수가 끝날 때 두 소유자가 각자의 메모리를 해제합니다.

std::vector<int> values(count);
std::string label = "dynamic values";
auto answer =
    std::make_unique<int>(42);

int* view = answer.get();
// answer보다 짧게 사용한다.

std::vector<int> values(count);
std::string label = "dynamic values";
auto answer =
    std::make_unique<int>(42);

int* view = answer.get();
// answer보다 짧게 사용한다.

count가 0이면 빈 vector가 만들어지며, 빈 vector의 front()는 호출하면 안 되므로 먼저 반환합니다. 출력에는 해제가 보이지 않지만, 해제는 소유자의 타입이 보장하는 동작입니다. 이처럼 어느 경로로 끝나도 같은 규칙으로 정리되므로, 분기를 추가해도 delete를 빠뜨릴 일이 생기지 않습니다.

무엇을 고를까

std::unique_ptr<T[]>로 배열을 소유할 수도 있지만, 크기를 기억하고 반복하는 일이 많은 보통의 경우에는 std::vector가 더 알맞습니다. 직접 new와 delete를 써야 하는 저수준 코드라면, 누가 소유하는지, 어떤 형태로 할당했는지, 모든 종료 경로에서 정확히 한 번 해제되는지를 함께 확인합니다. 목표는 delete를 잘 기억하는 것이 아니라, 소유를 타입으로 드러내 delete를 쓸 일 자체를 없애는 것입니다.

정리

• new는 실행 중에 객체를 만들어 포인터를 돌려주며, 그 객체는 직접 없앨 때까지 남습니다.
• 단일 객체는 delete, 배열은 delete[]로 해제하며, 짝이 맞지 않거나 두 번 해제하면 정의되지 않은 동작입니다.
• 일반 new는 할당에 실패하면 nullptr이 아니라 std::bad_alloc 예외를 던집니다.
• 포인터 하나에 nullptr을 대입해도 같은 객체를 가리키는 다른 포인터는 해제된 주소를 그대로 들고 있습니다.
• 수동 해제는 조기 반환과 예외 경로에서 빠지기 쉬우므로, 소유를 std::vector, std::string, std::unique_ptr 같은 RAII 객체에 맡깁니다.

연습 문제

1. 해제 뒤의 별칭

alias.cpp에서 delete owner; 직후에 값이 7인 int는 아직 살아 있나요? owner = nullptr;까지 실행한 뒤 delete alias;를 하면 정리가 더 확실해지나요?

2. 짝이 맞지 않는 해제

int* p = new int[3]{1, 2, 3}; 다음에 delete p;로 해제하면 어떻게 되나요? 어떻게 고치는 것이 가장 좋나요?

3. 두 번째 할당이 실패하면

다음 함수에서 두 번째 new가 std::bad_alloc을 던지면 a가 가리키는 객체는 어떻게 되나요? std::make_unique로 바꾸면 어떻게 되나요?

void make_pair_of_values() {
    int* a = new int{1};
    int* b = new int{2};
    // a와 b 사용
    delete b;
    delete a;
}

다음 글 참조자에서는 이미 있는 객체에 다른 이름을 붙이는 참조를 다루고, 포인터와 어떻게 다른지 비교합니다.