c++ - type - cppreference assignment operator

복사 및 스왑 이디엄이란 무엇입니까? (4)

개요

복사 및 스왑 이디엄이 필요한 이유는 무엇입니까?

리소스 (스마트 포인터와 같은 래퍼) 를 관리하는 모든 클래스는 The Big Three 를 구현해야합니다. 복사 생성자와 소멸자의 목표와 구현은 간단하지만 복사 할당 연산자는 가장 미묘하고 어려울 것입니다. 어떻게해야합니까? 어떤 함정을 피해야합니까?

카피 - 스왑 (copy-and-swap) 관용구 는 솔루션이며, 할당 연산자가 코드 중복을 피하고 강력한 예외 보장을 제공한다는 두 가지를 달성하는 데 우아하게 도움을줍니다.

어떻게 작동합니까?

Conceptually 복사 생성자의 기능을 사용하여 데이터의 로컬 복사본을 만든 다음 복사 된 데이터를 swap 함수로 가져와 이전 데이터를 새 데이터로 바꿉니다. 그런 다음 임시 복사본이 삭제되고 이전 데이터가 삭제됩니다. 새로운 데이터의 복사본이 남아 있습니다.

copy-and-swap 관용구를 사용하려면 작업 복사본 생성자, 작업 소멸자 (둘 다 래퍼의 기초이므로 어쨌든 완료해야 함)와 swap 함수의 세 가지가 필요합니다.

스왑 함수는 클래스의 두 객체 (멤버의 멤버)를 서로 바꿔주는 비 던진 (non-throwing) 함수입니다. 우리 자신을 제공하는 대신 std::swap 을 사용하도록 유혹 될 수도 있지만 이는 불가능할 수 있습니다. std::swap 은 구현 내에서 복사 생성자와 복사 할당 연산자를 사용하며 궁극적으로 할당 연산자를 자체적으로 정의하려고합니다.

(그뿐만 아니라 스 swap 부적합한 호출은 std::swap 이 필요로하는 클래스의 불필요한 생성 및 파기를 건너 뛰고 커스텀 스왑 연산자를 사용할 것입니다.)

심층 설명

목표

구체적인 경우를 생각해 봅시다. 우리는 무의미한 클래스에서 동적 배열을 관리하려고합니다. 우리는 작업 생성자, 복사 생성자 및 소멸자로 시작합니다.

#include <algorithm> // std::copy
#include <cstddef> // std::size_t

class dumb_array
{
public:
    // (default) constructor
    dumb_array(std::size_t size = 0)
        : mSize(size),
          mArray(mSize ? new int[mSize]() : nullptr)
    {
    }

    // copy-constructor
    dumb_array(const dumb_array& other)
        : mSize(other.mSize),
          mArray(mSize ? new int[mSize] : nullptr),
    {
        // note that this is non-throwing, because of the data
        // types being used; more attention to detail with regards
        // to exceptions must be given in a more general case, however
        std::copy(other.mArray, other.mArray + mSize, mArray);
    }

    // destructor
    ~dumb_array()
    {
        delete [] mArray;
    }

private:
    std::size_t mSize;
    int* mArray;
};

이 클래스는 배열을 거의 성공적으로 관리하지만 올바르게 작동하려면 operator= 가 필요합니다.

실패한 솔루션

다음은 순진한 구현 방식을 보여줍니다.

// the hard part
dumb_array& operator=(const dumb_array& other)
{
    if (this != &other) // (1)
    {
        // get rid of the old data...
        delete [] mArray; // (2)
        mArray = nullptr; // (2) *(see footnote for rationale)

        // ...and put in the new
        mSize = other.mSize; // (3)
        mArray = mSize ? new int[mSize] : nullptr; // (3)
        std::copy(other.mArray, other.mArray + mSize, mArray); // (3)
    }

    return *this;
}

그리고 우리는 우리가 끝났다고 말한다. 이제는 누출없이 어레이를 관리합니다. 그러나 코드에서 (n) 으로 순차적으로 표시되는 세 가지 문제가 있습니다.

1. 첫 번째는 자체 할당 테스트입니다. 이 검사는 두 가지 목적을 수행합니다. 즉, 자체 할당시 불필요한 코드를 실행하지 못하도록하는 쉬운 방법이며 미묘한 버그 (예 : 배열을 삭제하고 복사하는 등)로부터 우리를 보호합니다. 그러나 다른 모든 경우에는 프로그램을 느리게 실행하고 코드에서 소음으로 작용합니다. 자체 할당이 거의 발생하지 않으므로 대부분이 시간을 낭비합니다. 운영자가 없이도 제대로 작동한다면 더 좋을 것입니다.

2. 두 번째는 기본 예외 보증 만 제공한다는 것입니다. new int[mSize] 가 실패하면 *this 수정됩니다. (즉, 크기가 잘못되어 데이터가 사라졌습니다!) 강력한 예외 보증을 위해서는 다음과 같은 것이 필요합니다.

   dumb_array& operator=(const dumb_array& other)
   {
       if (this != &other) // (1)
       {
           // get the new data ready before we replace the old
           std::size_t newSize = other.mSize;
           int* newArray = newSize ? new int[newSize]() : nullptr; // (3)
           std::copy(other.mArray, other.mArray + newSize, newArray); // (3)
   
           // replace the old data (all are non-throwing)
           delete [] mArray;
           mSize = newSize;
           mArray = newArray;
       }
   
       return *this;
   }
   

3. 코드가 확장되었습니다! 따라서 세 번째 문제가 생깁니다 : 코드 중복. 할당 연산자는 이미 다른 곳에서 작성한 모든 코드를 효과적으로 복제합니다. 이것은 끔찍한 일입니다.

우리의 경우 핵심은 두 줄 (할당 및 사본)이지만 더 복잡한 리소스를 사용하면이 코드가 부 풀리는 것은 상당히 번거로운 작업이 될 수 있습니다. 우리는 결코 반복하지 않기 위해 노력해야합니다.

(하나의 리소스를 올바르게 관리하기 위해 많은 코드가 필요하다면, 내 클래스가 하나 이상의 리소스를 관리한다면 어떨까요? 이것은 중요한 문제인 것처럼 보일 수 있지만 실제로는 try / catch 절을 필요로하지 않습니다. 클래스는 하나의 리소스 만 관리해야하기 때문입니다!)

성공적인 솔루션

앞서 언급했듯이 복사 및 스왑 이디엄은 이러한 모든 문제를 해결합니다. 하지만 지금은 swap 기능을 제외한 모든 요구 사항이 있습니다. The Rule of Three는 성공적으로 복사 생성자, 할당 연산자 및 소멸자의 존재를 수반하지만 실제로는 "Big Three and A Half"라고해야합니다 : 클래스가 리소스를 관리 할 때마다 swap 을 제공하는 것이 좋습니다 기능.

클래스에 스왑 기능을 추가해야합니다. † 다음과 같이합니다.

class dumb_array
{
public:
    // ...

    friend void swap(dumb_array& first, dumb_array& second) // nothrow
    {
        // enable ADL (not necessary in our case, but good practice)
        using std::swap;

        // by swapping the members of two objects,
        // the two objects are effectively swapped
        swap(first.mSize, second.mSize);
        swap(first.mArray, second.mArray);
    }

    // ...
};

(왜 public friend swap 하는지에 대한 설명이 있습니다.) 이제 우리는 우리의 dumb_array 을 바꿀 수있을뿐만 아니라, 일반적으로 스왑이 더 효율적일 수 있습니다. 전체 배열을 할당하고 복사하는 것이 아니라 단순히 포인터와 크기를 서로 바꿉니다. 기능과 효율성면에서이 보너스를 제외하고 이제 복사 및 스왑 이디엄을 구현할 준비가되었습니다.

추측없이, 우리의 대입 연산자는 다음과 같습니다.

dumb_array& operator=(dumb_array other) // (1)
{
    swap(*this, other); // (2)

    return *this;
}

그리고 그게 다야! 하나가 급습하자 세 가지 문제가 모두 우아하게 처리되었습니다.

왜 작동합니까?

우리는 우선 중요한 선택을 주목합니다 : 매개 변수 인수는 값에 의해 취해진 것입니다. 그럼에도 불구하고 다음과 같은 작업을 쉽게 수행 할 수 있습니다 (실제로 많은 숙련 된 구현 방식이 가능합니다).

dumb_array& operator=(const dumb_array& other)
{
    dumb_array temp(other);
    swap(*this, temp);

    return *this;
}

우리는 중요한 최적화 기회를 놓치게됩니다. 뿐만 아니라이 선택 사항은 나중에 설명 할 C ++ 11에서 중요합니다. (일반적으로 매우 유용한 지침은 다음과 같습니다 : 함수에서 무언가의 복사본을 만들려면 컴파일러가 매개 변수 목록에서이를 수행하도록하십시오.) ‡)

어느 쪽이든, 우리의 자원을 얻는이 방법은 코드 중복을 제거하는 열쇠입니다. 복사 생성자의 코드를 사용하여 복사본을 만들고, 그 코드를 반복 할 필요가 없습니다. 사본이 만들어지기 때문에, 우리는 교환 할 준비가되었습니다.

새로운 데이터가 모두 이미 할당되고 복사되고 사용될 준비가되었다는 것을 함수에 입력하면 관찰하십시오. 이것이 우리에게 무료로 강력한 예외 보증을 제공하는 것입니다. 복사의 구성이 실패하면 함수를 입력하지 않기 때문에 *this 상태를 변경할 수 없습니다. (우리가 강력하게 예외를 보장하기 위해 수동으로했던 것은 컴파일러가 지금 우리를 위해하고있는 것입니다.)

swap 은 비 던지기 때문에이 시점에서 우리는 집이 없습니다. 현재 데이터를 복사 된 데이터와 교환하여 상태를 안전하게 변경하고 오래된 데이터를 임시로 가져옵니다. 그런 다음 함수가 반환 될 때 이전 데이터가 해제됩니다. (여기서 매개 변수의 범위가 끝나고 소멸자가 호출됩니다.)

관용구는 코드를 반복하지 않기 때문에 연산자 내에 버그를 도입 할 수 없습니다. 이는 우리가자가 할당 검사의 필요성을 없앰으로써 operator= 단일하게 구현할 수 있음을 의미합니다. (또한 비 자체 할당에 대한 성능 저하는 더 이상 발생하지 않습니다.)

이것이 복사 및 스왑 이디엄입니다.

C ++ 11은 어떻습니까?

C ++의 차기 버전 인 C ++ 11은 우리가 자원을 관리하는 방법에있어 매우 중요한 변화 중 하나입니다. 규칙 3은 이제 4의 규칙입니다 . 왜? 자원을 복사 할 수 있어야 할 뿐만 아니라 이동도해야합니다 .

다행스럽게도 우리에게는 쉽습니다.

class dumb_array
{
public:
    // ...

    // move constructor
    dumb_array(dumb_array&& other)
        : dumb_array() // initialize via default constructor, C++11 only
    {
        swap(*this, other);
    }

    // ...
};

무슨 일 이니? 이동 건설의 목표 : 클래스의 다른 인스턴스에서 리소스를 가져 와서 할당 가능하고 파괴 가능하도록 보장 된 상태로 둡니다.

그래서 우리가 한 일은 간단합니다. 기본 생성자 (C ++ 11 기능)를 통해 초기화 한 다음 other 교체합니다. 클래스의 기본 생성 된 인스턴스가 안전하게 할당되고 소멸 될 수 있다는 것을 알기 때문에 스와핑 후에도 other 클래스가 동일하게 수행 할 수 있습니다.

일부 컴파일러는 생성자 위임을 지원하지 않으므로이 경우 수동으로 클래스를 생성해야합니다. 이는 불행하지만 다행히도 사소한 작업입니다.

왜 그게 효과가 있니?

그것은 우리가 수업에해야 할 유일한 변화입니다. 그렇다면 왜 효과가 있습니까? 매개 변수를 참조가 아닌 값으로 만들기 위해 우리가 결정한 중요한 결정을 기억하십시오.

dumb_array& operator=(dumb_array other); // (1)

이제, 만약 other 값이 rvalue로 초기화된다면, 그것은 움직일 것 입니다. 완전한. 같은 방식으로 C ++ 03은 인수에 의한 인수를 취하여 복사 생성자 기능을 다시 사용하게하고 C ++ 11은 적절할 때 자동으로 이동 생성자를 선택합니다. (물론 이전에 링크 된 기사에서 언급했듯이 값의 복사 / 이동은 모두 생략 할 수 있습니다.)

복사 및 스왑 이디엄을 결론지었습니다.

각주

* 왜 mArray 를 null로 설정합니까? 연산자의 더 이상의 코드가 throw되면 dumb_array 의 소멸자가 dumb_array 될 수 있습니다. null로 설정하지 않고 이런 일이 발생하면 이미 삭제 된 메모리를 삭제하려고 시도합니다! null을 삭제하는 것은 아무런 작업이 아니므로 null로 설정하여이를 방지합니다.

† 우리 유형에 대해 std::swap 을 전문화해야하고, 클래스 내 swap 과 함께 자유 기능 swap 등을 제공해야한다는 다른 주장이 있습니다. 그러나 이것은 모두 불필요합니다 : swap 적절한 사용은 자격이없는 것입니다 전화를 걸면 우리의 기능은 ADL 통해 발견 될 것입니다. 한 가지 기능 만 수행합니다.

‡ 이유는 간단합니다. 일단 리소스를 소유하고 나면 언제 어디서나 스왑하거나 이동할 수 있습니다 (C ++ 11). 매개 변수 목록에서 사본을 작성하면 최적화가 최대화됩니다.