이동 생성자가 실제로 하는 일을 어셈블리로 복사와 비교해 알아봅니다.


돌아가기

프로그래밍 언어

방정현

목차

이동 의미론 : 2. 이동은 실제로 무엇을 하는가

개요

이 글은 이동 의미론(move semantics)을 다루는 시리즈의 두 번째 글입니다. 1편에서는 복사가 왜 비싼가에서 출발해, 값 카테고리가 어떤 표현식을 훔쳐도 되는지 판별하고, 오버로드 해소가 그 판별 결과에 따라 복사와 이동 중 하나를 선택한다는 것을 알아봤습니다. 그런데 거기서 한 가지를 계속 미뤄 두었습니다. 이동 생성자가 선택된다는 것까지만 말했을 뿐, 정작 그 이동 생성자 안에서 무슨 일이 일어나는지 아직 모릅니다.

이 글에서 다루는 범위는 다음과 같습니다.

std::move와 std::forward의 내부 구현, 그리고 완벽 전달은 다음 글에서 다룹니다.


1. 이동 생성자와 이동 대입의 실제 동작

소개

1편의 Buffer에 이동 생성자를 직접 작성해 보겠습니다. 개념으로만 설명했던 ‘포인터를 넘겨받고 원본을 비운다’를 코드로 옮기면 다음과 같습니다.

Buffer(Buffer&& other) noexcept
    : Data(other.Data), Size(other.Size)   // 원본의 포인터와 크기를 가져옴
{
    other.Data = nullptr;   // 원본을 비워 소유권을 넘김
    other.Size = 0;
}

이동 생성자

동작은 두 단계입니다. 먼저 원본 other의 Data(힙 버퍼를 가리키는 포인터)와 Size를 새 객체에 할당합니다. 이 시점에는 두 객체가 같은 버퍼를 가리키며, 이는 1편의 얕은 복사와 동일한 상태입니다. 그다음 other.Data를 nullptr로 만들어 원본이 더 이상 그 버퍼를 소유하지 않게 합니다. 이 한 단계가 이중 해제를 막는 핵심입니다. 만약 이 단계를 건너뛰면 두 객체가 같은 버퍼를 가리키다가 둘 다 소멸할 때 같은 메모리를 두 번 해제하게 됩니다. 원본을 nullptr로 비우면 이후 other가 소멸할 때 nullptr을 delete[]하므로 안전하고, 버퍼의 유일한 소유자는 새 객체가 됩니다.

이동 대입 연산자

이동 대입 연산자는 이미 존재하는 객체에 대입하는 것이므로 두 가지가 더 필요합니다. 하나는 대입 대상이 원래 들고 있던 버퍼를 먼저 해제하는 것이고(그러지 않으면 자원 누수), 다른 하나는 자기 자신에게 이동 대입하는 경우를 방어하는 것입니다.

Buffer& operator=(Buffer&& other) noexcept 
{
    if (this != &other) 
    {                           // self-move 방어
        delete[] Data;          // 내가 쓰던 버퍼 해제
        Data = other.Data;      // 원본의 버퍼를 가져옴
        Size = other.Size;
        other.Data = nullptr;   // 원본을 비움
        other.Size = 0;
    }
    return *this;
}

<aside>

짚고 가기 — self-move 방어인 this != &other 검사가 없으면 x = std::move(x) 같은 상황에서 자신의 버퍼를 delete[]한 직후 그 해제된 포인터를 다시 가져오게 됩니다. 표준은 사용자 정의 이동 대입이 자기 이동 대입으로 객체를 망가뜨리지 않도록 막아야 한다고 규정하며, 자기 대입 검사나 move-and-swap 관용 패턴으로 처리합니다.

</aside>

noexcept

이동 생성자와 이동 대입에 noexcept를 붙였습니다. 이것은 관례가 아니라 성능과 직결됩니다. std::vector 같은 컨테이너가 재할당할 때 이동 연산이 noexcept가 아니면 예외 안전을 위해 이동 대신 복사를 선택하기 때문입니다. 이 메커니즘의 상세는 다음 글의 성능 함정에서 다루므로, 여기서는 이동 연산에는 noexcept를 붙인다는 것까지만 짚어 둡니다.


2. 어셈블리로 확인 : 복사 vs 이동

소개

이동이 정말로 복사보다 저렴한지는 컴파일된 어셈블리를 보면 명확해집니다. 직접 확인하는 방법은 간단합니다. godbolt.org에 접속해 왼쪽에 C++ 코드를 붙여넣고, 컴파일러를 선택한 뒤 옵션에 -O2를 입력하면 오른쪽에 어셈블리가 실시간으로 나타납니다. 1절의 Buffer 코드를 붙여넣고 복사 생성자와 이동 생성자를 각각 호출하는 함수를 만들면 두 경우의 어셈블리를 나란히 비교할 수 있습니다.

코드에서 std::move(src)를 사용했습니다. 이는 컴파일러가 std::move를 내부적으로 어떻게 처리하는지 보여주기 위함인데, 실제로 std::move는 이 코드의 내부 구현(즉, static_cast<Buffer&&>)을 단순하게 래핑한 것입니다.

복사 생성자의 어셈블리

image.png

복사 생성자는 새 버퍼를 확보하고 내용을 통째로 옮깁니다. 어셈블리에는 operator new 호출(힙 할당)과 N바이트를 복사하는 memcpy 호출(N바이트 복사)이 나타납니다. 할당은 OS에 메모리를 요청하는 비싼 호출이고, memcpy는 한 번 호출되지만 내부에서 N바이트만큼의 복사를 수행하므로 연산량이 버퍼 크기 N에 비례합니다.

이동 생성자의 어셈블리

image.png

이동 생성자는 할당도 내용 복사도 하지 않습니다. 어셈블리에 나타나는 것은 포인터와 크기 값을 옮기는 mov 명령뿐이고, 전부 고정된 크기의 상수 시간 작업입니다. 버퍼가 1바이트든 1GB든 연산량은 똑같으며, 이것이 이동이 O(1)인 이유입니다.

<aside>

짚고 가기 — std::move(b1) 자체는 어셈블리 명령을 생성하지 않습니다. std::move는 런타임 동작이 아니라 컴파일러에게 "이 b1을 rvalue로 봐"라고 알려주는 것뿐입니다. 실제 이동은 이동 생성자가 호출될 때 일어납니다. C++에는 이처럼 컴파일러의 판단에만 관여하고 런타임에는 비용을 남기지 않는 코드가 있으며, 이를 zero-cost abstraction(비용 없는 추상화)이라 합니다. 위의 어셈블리 명령들은 전부 이동 생성자의 코드가 생성한 것이지, std::move가 생성한 것이 아닙니다.

</aside>

정리

연산 시간 복잡도 내용
복사 생성자 O(n) 새 메모리 할당 + N바이트 복사
이동 생성자 O(1) 포인터와 크기만 이전

3. Rule of Five

소개

1편에서 직접 해제해야 하는 자원을 소유한 타입은 소멸자, 복사 생성자, 복사 대입 연산자를 함께 정의해야 한다는 Rule of Three를 보았습니다. C++11이 이동 생성자와 이동 대입 연산자를 추가하면서 이 목록은 다섯으로 늘어납니다. 즉 소멸자, 복사 생성자, 복사 대입, 이동 생성자, 이동 대입 연산자입니다.

왜 다섯 함수를 구현해야 하는가

근본 원인은 1편과 같습니다. 직접 해제해야 하는 자원을 직접 소유하기 때문입니다. 이 다섯 함수가 자원을 다루는 방식이 어긋나면 이중 해제나 누수가 발생합니다.

자동 생성 규칙

여기에 중요한 언어 규칙이 하나 있습니다. 사용자가 소멸자나 복사 연산 중 하나라도 직접 정의하면 이동 생성자와 이동 대입 연산자는 자동으로 생성되지 않습니다. 따라서 직접 해제해야 하는 자원을 소유해 소멸자를 정의한 타입은 이동 연산도 명시적으로 정의하지 않으면 이동이 아니라 복사로 처리됩니다.

<aside>

짚고 가기 — 반대로 자원 관리를 스마트 포인터 같은 타입에 위임하면 다섯 함수를 하나도 직접 정의할 필요가 없습니다. 컴파일러가 생성한 기본 연산이 위임된 멤버의 이동과 복사를 알아서 호출하기 때문입니다. 이를 Rule of Zero라고 합니다.

</aside>


4. moved-from 상태

소개

이동은 원본의 자원을 가져가고 원본을 비웁니다. 그렇다면 자원을 넘겨준 뒤 남은 원본은 어떤 상태일까요. 표준은 이를 valid but unspecified state(유효하지만 미지정 상태)로 규정합니다.

무엇이 보장되나

유효하다는 것은 객체의 클래스 불변식이 유지된다는 뜻입니다. 따라서 전제조건이 없는 연산은 안전합니다.

안전한 연산들:

Buffer b1(1024);           // b1 생성
Buffer b2 = std::move(b1); // b1이 b2로 이동됨. b1은 valid but unspecified state

if (b1.Size() == 0) { }    // ✅ 안전. Size()는 전제조건이 없음
b1.~Buffer();              // ✅ 안전. moved-from 상태에서도 소멸자는 안전
Buffer b3 = std::move(b1); // ✅ 안전. b1을 다시 이동 대입해도 됨

반대로 moved-from 상태의 객체를 사용할 수 없는 연산도 있습니다:

std::cout << b1[0];    // ❌ 위험. b1.Data == nullptr일 수 있음
b1.Resize(100);        // ❌ 정의되지 않은 동작

moved-from 상태의 객체를 재사용하지 않는다

그래서 규칙은 단순합니다. std::move한 원본은 다시 대입하기 전까지 값을 읽지 않습니다. std::move(x)를 했다고 x가 파괴되는 것은 아니지만(1편에서 본 대로 std::move는 표시일 뿐이고 실제 이동은 이동 생성자나 이동 대입이 호출될 때 일어납니다), 실제 이동이 일어난 뒤의 x는 미지정 상태이므로 그 값에 의존하면 안 됩니다.

<aside>

짚고 가기 — 공유되는 스마트 포인터를 예로 들면, shared_ptr을 이동해도 그 객체를 함께 가리키던 다른 shared_ptr들은 참조 카운트 덕에 안전하며 크래시가 나지 않습니다. 위험한 것은 오직 이동당한 원본 변수 자체로, 그것이 비워진 뒤 역참조하면 문제가 됩니다. 크래시의 원인은 공유가 아니라 비워진 원본의 재사용입니다.

</aside>


정리

이 글은 1편이 미뤄 둔 질문, 즉 선택된 이동 생성자가 실제로 무엇을 하는가에 답했습니다.

그렇다면 std::move는 정말로 무엇일까요? 다음 글에서는 std::move가 실제로는 static_cast일 뿐이라는 내부 구현과, forwarding reference·레퍼런스 축약을 통한 완벽 전달을 다룹니다.

참고


E-mail : [email protected] Phone number : (+82) 010 3902 8624