기본 이동 할당 / 이동 생성자가없는 이유는 무엇입니까?

저는 단순한 프로그래머입니다. 내 클래스 멤버 변수는 대부분 POD 유형과 STL 컨테이너로 구성됩니다. 이 때문에 기본적으로 구현되는 할당 연산자 나 복사 생성자를 거의 작성할 필요가 없습니다.

여기에 std::move움직일 수없는 물체에 사용하면 할당 연산자를 활용하므로 std::move완벽하게 안전합니다.

나는 단순한 프로그래머이기 때문에 컴파일러가 단순히 " this->member1_ = std::move(other.member1_);..." 로 구현할 수 있었기 때문에 내가 작성하는 모든 클래스에 이동 생성자 / 할당 연산자를 추가하지 않고 이동 기능을 활용하고 싶습니다.

그러나 그렇지 않습니다 (적어도 Visual 2010에서는 아님), 이것에 대한 특별한 이유가 있습니까?

더 중요한 것은; 이 문제를 해결할 방법이 있습니까?

업데이트 : GManNickG의 답변을 보면 그는 이에 대한 훌륭한 매크로를 제공합니다. 모르는 경우 이동 시맨틱을 구현하면 스왑 멤버 함수를 제거 할 수 있습니다.

이동 생성자 및 할당 연산자의 암시 적 생성은 논쟁의 여지가 있었고 C ++ 표준의 최근 초안에 주요 수정이 있었으므로 현재 사용 가능한 컴파일러는 암시 적 생성과 관련하여 다르게 동작 할 것입니다.

문제의 역사에 대한 자세한 내용 은 2010 WG21 논문 목록을 참조 하고 "mov"를 검색 하십시오 .

현재 사양 (N3225, 11 월부터)에는 다음과 같이 명시되어 있습니다 (N3225 12.8 / 8).

클래스 정의가 X이동 생성자를 명시 적으로 선언하지 않으면 다음과 같은 경우에만 기본값으로 암시 적으로 선언됩니다.

• X 사용자가 선언 한 복사 생성자가 없습니다.

• X 사용자가 선언 한 복사 할당 연산자가 없습니다.

• X 사용자가 선언 한 이동 할당 연산자가 없습니다.

• X 사용자가 선언 한 소멸자가 없습니다.

• 이동 생성자는 암시 적으로 삭제 된 것으로 정의되지 않습니다.

이동 할당 연산자가 암시 적으로 기본값으로 선언되는시기를 지정하는 유사한 언어가 12.8 / 22에 있습니다. Bjarne Stroustrup의 논문 N3201 : Moving right along 에서 제안한 해결 방법 중 하나를 주로 기반으로하는 N3203 : 암시 적 이동 생성 조건 강화 에서 암시 적 이동 생성의 현재 사양을 지원하기 위해 만들어진 전체 변경 목록을 찾을 수 있습니다 .

암시 적으로 생성 된 이동 생성자는 표준으로 고려되었지만 위험 할 수 있습니다. Dave Abrahams의 분석을 참조하십시오 .

그러나 결국 표준에는 상당한 제한 목록이 있지만 이동 생성자와 이동 할당 연산자의 암시 적 생성이 포함되었습니다.

클래스 X의 정의가 이동 생성자를 명시 적으로 선언하지 않으면 다음 경우에만 기본값으로 암시 적으로 선언됩니다.
X에 사용자 선언 복사 생성자
가없는 경우 , — X에 사용자 선언 복사 할당 연산자가없는 경우 ,
— X에는 사용자가 선언 한 이동 할당 연산자
가 없습니다. — X에는 사용자가 선언 한 소멸자가 없습니다. 그리고
— 이동 생성자는 암시 적으로 삭제 된 것으로 정의되지 않습니다.

하지만 그게 전부는 아닙니다. ctor를 선언 할 수 있지만 여전히 삭제 된 것으로 정의됩니다.

암시 적으로 선언 된 복사 / 이동 생성자는 해당 클래스의 인라인 공용 멤버입니다. X 클래스에 대한 기본 복사 / 이동 생성자는 X가 다음과 같은 경우 삭제 (8.4.3)로 정의됩니다.

— 사소하지 않은 대응 생성자를 가진 변형 멤버이고 X는 공용체와 같은 클래스입니다.
— 과부하 해결 (13.3) 때문에 복사 / 이동할 수없는 클래스 유형 M (또는 그 배열)의 비 정적 데이터 멤버 M의 해당 생성자에 적용하면 기본 생성자에서 삭제되거나 액세스 할 수없는 모호성 또는 함수가
발생합니다. B의 해당 생성자에 적용된 오버로드 해결 (13.3)로 인해 복사 / 이동할 수없는 직접 또는 가상 기본 클래스 B , 기본 생성자에서 삭제되거나 액세스 할 수없는 모호성 또는 함수 (
— 삭제되거나 액세스 할 수없는 소멸자가있는 유형의 모든 직접 또는 가상 기본 클래스 또는 비 정적 데이터 멤버
— 복사 생성자의 경우 rvalue 참조 유형
의 비 정적 데이터 멤버 또는 — 이동 생성자의 경우 이동 생성자가없고 단순하지 않은 유형의 비 정적 데이터 멤버 또는 직접 또는 가상 기본 클래스 복사 가능.

(지금은 어리석은 매크로 작업 중입니다 ...)

그래, 나도 그 길을 갔다. 매크로는 다음과 같습니다.

// detail/move_default.hpp
#ifndef UTILITY_DETAIL_MOVE_DEFAULT_HPP
#define UTILITY_DETAIL_MOVE_DEFAULT_HPP

#include <boost/preprocessor.hpp>

#define UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR_BASE(pR, pData, pBase) pBase(std::move(pOther))
#define UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT_BASE(pR, pData, pBase) pBase::operator=(std::move(pOther));

#define UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR(pR, pData, pMember) pMember(std::move(pOther.pMember))
#define UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT(pR, pData, pMember) pMember = std::move(pOther.pMember);

#define UTILITY_MOVE_DEFAULT_DETAIL(pT, pBases, pMembers)                                               \
        pT(pT&& pOther) :                                                                               \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(                                                       \
            UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR_BASE, BOOST_PP_EMPTY, pBases))                      \
        ,                                                                                               \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(                                                       \
            UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR, BOOST_PP_EMPTY, pMembers))                         \
        {}                                                                                              \
                                                                                                        \
        pT& operator=(pT&& pOther)                                                                      \
        {                                                                                               \
            BOOST_PP_SEQ_FOR_EACH(UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT_BASE, BOOST_PP_EMPTY, pBases)  \
            BOOST_PP_SEQ_FOR_EACH(UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT, BOOST_PP_EMPTY, pMembers)     \
                                                                                                        \
            return *this;                                                                               \
        }

#define UTILITY_MOVE_DEFAULT_BASES_DETAIL(pT, pBases)                                                   \
        pT(pT&& pOther) :                                                                               \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(                                                       \
            UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR_BASE, BOOST_PP_EMPTY, pBases))                      \
        {}                                                                                              \
                                                                                                        \
        pT& operator=(pT&& pOther)                                                                      \
        {                                                                                               \
            BOOST_PP_SEQ_FOR_EACH(UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT_BASE, BOOST_PP_EMPTY, pBases)  \
                                                                                                        \
            return *this;                                                                               \
        }

#define UTILITY_MOVE_DEFAULT_MEMBERS_DETAIL(pT, pMembers)                                               \
        pT(pT&& pOther) :                                                                               \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(                                                       \
            UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR, BOOST_PP_EMPTY, pMembers))                         \
        {}                                                                                              \
                                                                                                        \
        pT& operator=(pT&& pOther)                                                                      \
        {                                                                                               \
            BOOST_PP_SEQ_FOR_EACH(UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT, BOOST_PP_EMPTY, pMembers)     \
                                                                                                        \
            return *this;                                                                               \
        }

#endif

​

// move_default.hpp
#ifndef UTILITY_MOVE_DEFAULT_HPP
#define UTILITY_MOVE_DEFAULT_HPP

#include "utility/detail/move_default.hpp"

// move bases and members
#define UTILITY_MOVE_DEFAULT(pT, pBases, pMembers) UTILITY_MOVE_DEFAULT_DETAIL(pT, pBases, pMembers)

// base only version
#define UTILITY_MOVE_DEFAULT_BASES(pT, pBases) UTILITY_MOVE_DEFAULT_BASES_DETAIL(pT, pBases)

// member only version
#define UTILITY_MOVE_DEFAULT_MEMBERS(pT, pMembers) UTILITY_MOVE_DEFAULT_MEMBERS_DETAIL(pT, pMembers)

#endif

(길이와 다큐멘터리 인 실제 댓글은 삭제했습니다.)

클래스의 기본 및 / 또는 멤버를 전 처리기 목록으로 지정합니다. 예를 들면 다음과 같습니다.

#include "move_default.hpp"

struct foo
{
    UTILITY_MOVE_DEFAULT_MEMBERS(foo, (x)(str));

    int x;
    std::string str;
};

struct bar : foo, baz
{
    UTILITY_MOVE_DEFAULT_BASES(bar, (foo)(baz));
};

struct baz : bar
{
    UTILITY_MOVE_DEFAULT(baz, (bar), (ptr));

    void* ptr;
};

그리고 이동 생성자와 이동 할당 연산자가 나옵니다.

(제쳐두고, 내가 세부 사항을 하나의 매크로로 결합하는 방법을 아는 사람이 있다면 그것은 부풀어 오를 것입니다.)

VS2010은 구현 당시 표준이 아니기 때문에이를 수행하지 않습니다.