개요

복사 및 교체 관용구가 필요한 이유는 무엇입니까?

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

복사 및 스왑 관용구 의 해결책이 우아 두 가지를 달성 대입 연산자를 지원합니다 : 피 코드 중복을 , 그리고 제공하는 강력한 예외 보증을 .

어떻게 작동합니까?

개념적으로 복사 생성자의 기능을 사용하여 데이터의 로컬 복사본을 만든 다음 swap함수로 복사 된 데이터를 가져 와서 이전 데이터를 새 데이터로 교체합니다. 그런 다음 임시 사본은 오래된 데이터를 가져 와서 폐기합니다. 새 데이터의 사본이 남았습니다.

복사 및 스왑 이디엄을 사용하려면 작업중인 복사 생성자, 작업중인 소멸자 (둘 다 래퍼의 기초이므로 어쨌든 완료해야 함)와 swap함수의 세 가지가 필요 합니다.

스왑 함수는 멤버의 멤버 인 클래스의 두 개체를 스왑 하는 비 투사 함수입니다. 우리는 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함수. 3의 규칙은 우리의 복사 생성자, 할당 연산자 및 소멸자의 존재를 성공적으로 수반하지만 실제로는 “The 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;
}

그리고 그게 다야! 한 번의 실패로 세 가지 문제는 모두 한 번에 우아하게 해결됩니다.

왜 작동합니까?

우리는 먼저 중요한 선택을 알게되었습니다 : 매개 변수 인수는 by-value 입니다. 다음과 같은 작업을 쉽게 수행 할 수 있지만 실제로는 많은 순진한 관용구 구현이 가능합니다.

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) noexcept ††
        : dumb_array() // initialize via default constructor, C++11 only
    {
        swap(*this, other);
    }

    // ...
};

무슨 일이야? 이동 구성의 목표를 기억하십시오. 클래스의 다른 인스턴스에서 자원을 가져 와서 할당 가능하고 파괴 가능한 상태로 유지하십시오.

우리가 한 일은 간단합니다. 기본 생성자 (C ++ 11 기능)를 통해 초기화 한 다음 other; 우리는 클래스의 기본 생성 인스턴스가 안전하게 할당되고 소멸 other될 수 있다는 것을 알고 있으므로 스왑 후에도 동일한 작업을 수행 할 수 있습니다.

(일부 컴파일러는 생성자 위임을 지원하지 않습니다.이 경우 클래스를 수동으로 기본 구성해야합니다. 불행히도 운이 좋지 않은 작업입니다.)

왜 작동합니까?

그것이 우리 수업에 필요한 유일한 변화이므로 왜 효과가 있습니까? 매개 변수를 참조가 아닌 값으로 만들기 위해 항상 결정한 사항을 기억하십시오.

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

이제 otherrvalue로 초기화되는 경우 이동 구성 됩니다. 완전한. C ++ 03과 같은 방식으로 인수 값을 사용하여 복사 생성자 기능을 재사용 할 수 있습니다. C ++ 11은 적절한 경우 이동 생성자를 자동으로 선택합니다. (물론, 이전에 링크 된 기사에서 언급했듯이, 가치의 복사 / 이동은 단순히 제거 될 수 있습니다.)

그리고 복사 및 스왑 숙어를 마칩니다.

각주

* 왜 mArraynull로 설정 합니까? 연산자의 추가 코드가 발생하면 소멸자 dumb_array가 호출 될 수 있습니다. 그리고 null로 설정하지 않고 발생하면 이미 삭제 된 메모리를 삭제하려고 시도합니다! null을 삭제하면 작동하지 않으므로 null로 설정하여이를 방지합니다.

†이 우리가 전문 것을 청구에있는 std::swap우리의 유형은 수준의 제공 swap에 따른 측 무료 기능 swap등,하지만이 모든 불필요한입니다 :의 적절한 사용이 swap지정되지 않은 호출을 통해 될 것이며, 우리의 기능이있을 것 ADL을 통해 발견 . 하나의 기능이 수행됩니다.

‡ 이유는 간단합니다. 일단 리소스를 확보 한 후에는 필요할 때마다 리소스를 교환 및 / 또는 이동할 수 있습니다 (C ++ 11). 그리고 매개 변수 목록에 사본을 작성하여 최적화를 최대화합니다.

†† 이동 생성자는 일반적으로이어야합니다 noexcept. 그렇지 않으면 std::vector이동이 의미가있는 경우에도 일부 코드 (예 : 크기 조정 논리)가 복사 생성자를 사용합니다. 물론 내부 코드에서 예외가 발생하지 않는 경우에만 예외로 표시하십시오.

답변

T& operator=(T tmp)
{
    this->swap(tmp);
    return *this;
}

X& operator=(X rhs)
{
    swap(rhs);
    return *this;
}

struct X
{
    T* p_;
    size_t size_;
    X& operator=(const X& rhs)
    {
        delete[] p_;  // OUCH!
        p_ = new T[size_ = rhs.size_];
        std::copy(p_, rhs.p_, rhs.p_ + rhs.size_);
    }
    ...
};

struct Client
{
    IP_Address ip_address_;
    int socket_;
    X(const X& rhs)
      : ip_address_(rhs.ip_address_), socket_(connect(rhs.ip_address_))
    { }
};

friend void swap(A& first, A& second) {

    std::swap(first.size, second.size);
    std::swap(first.arr, second.arr);

}

void swap(A& other) {

    std::swap(size, other.size);
    std::swap(arr, other.arr);

}

void fs(std::vector<T, A> & a, std::vector<T, A> & b)
{
    a.swap(b);
    b.clear(); // not important what you do with b
}

void fm(std::vector<T, A> & a, std::vector<T, A> & b)
{
    a = std::move(b);
}