เหตุใดจึงไม่มีการกำหนดค่าการย้าย / ย้ายตัวสร้างเริ่มต้น

ฉันเป็นโปรแกรมเมอร์ธรรมดา ๆ ตัวแปรสมาชิกชั้นเรียนของฉันส่วนใหญ่มักประกอบด้วยประเภท POD และ STL-container ด้วยเหตุนี้ฉันจึงแทบไม่ต้องเขียนตัวดำเนินการกำหนดหรือคัดลอกตัวสร้างเนื่องจากจะใช้งานโดยค่าเริ่มต้น

เพิ่มสิ่งนี้ถ้าฉันใช้std::moveกับวัตถุที่ไม่สามารถเคลื่อนย้ายได้มันจะใช้ตัวดำเนินการกำหนดหมายความว่าstd::moveปลอดภัยอย่างสมบูรณ์

เนื่องจากฉันเป็นโปรแกรมเมอร์ธรรมดาฉันจึงต้องการใช้ประโยชน์จากความสามารถในการย้ายโดยไม่ต้องเพิ่มตัวสร้างการย้าย / ตัวดำเนินการกำหนดให้กับทุกชั้นเรียนที่ฉันเขียนเนื่องจากคอมไพเลอร์สามารถนำไปใช้เป็น " this->member1_ = std::move(other.member1_);..."

แต่มันไม่มี (อย่างน้อยก็ไม่ใช่ใน Visual 2010) มีเหตุผลพิเศษสำหรับสิ่งนี้หรือไม่?

ที่สำคัญกว่า; มีวิธีใดบ้างที่จะหลีกเลี่ยงสิ่งนี้?

อัปเดต: หากคุณมองลงไปที่คำตอบของ GManNickG เขาให้มาโครที่ยอดเยี่ยมสำหรับสิ่งนี้ และหากคุณไม่ทราบหากคุณใช้การย้ายความหมายคุณสามารถลบฟังก์ชัน swap member ได้

การสร้างตัวสร้างการเคลื่อนย้ายและตัวดำเนินการมอบหมายโดยนัยเป็นที่ถกเถียงกันและมีการแก้ไขครั้งใหญ่ในร่างมาตรฐาน C ++ ล่าสุดดังนั้นคอมไพเลอร์ที่มีอยู่ในปัจจุบันจึงมีแนวโน้มที่จะทำงานแตกต่างกันไปตามการสร้างโดยนัย

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับประวัติของปัญหาโปรดดูรายการเอกสาร WG21 ปี 2010และค้นหา "mov"

ข้อกำหนดปัจจุบัน (N3225 ตั้งแต่เดือนพฤศจิกายน) ระบุ (N3225 12.8 / 8):

หากคำจำกัดความของคลาสXไม่ได้ประกาศตัวสร้างการย้ายอย่างชัดเจนตัวสร้างการย้ายจะถูกประกาศโดยปริยายว่าเป็นค่าเริ่มต้นในกรณีที่

• X ไม่มีตัวสร้างการคัดลอกที่ผู้ใช้ประกาศและ

• X ไม่มีตัวดำเนินการกำหนดสำเนาที่ผู้ใช้ประกาศ

• X ไม่มีตัวดำเนินการกำหนดการย้ายที่ผู้ใช้ประกาศ

• X ไม่มีตัวทำลายที่ผู้ใช้ประกาศและ

• ตัวสร้างการย้ายจะไม่ถูกกำหนดโดยปริยายว่าถูกลบ

มีภาษาที่คล้ายกันใน 12.8 / 22 ระบุเมื่อตัวดำเนินการกำหนดการย้ายถูกประกาศโดยปริยายว่าเป็นค่าเริ่มต้น คุณสามารถค้นหารายการสินค้าทั้งหมดของการเปลี่ยนแปลงที่เกิดขึ้นกับสนับสนุนข้อกำหนดปัจจุบันของรุ่นย้ายนัยในN3203: กระชับเงื่อนไขสำหรับการสร้างการเคลื่อนไหวโดยปริยาย ซึ่งส่วนใหญ่จะขึ้นอยู่กับหนึ่งในมติที่เสนอโดยกระดาษ Bjarne Stroustrup ของN3201: การย้ายขวาพร้อม

ตัวสร้างการเคลื่อนย้ายที่สร้างขึ้นโดยนัยได้รับการพิจารณาสำหรับมาตรฐาน แต่อาจเป็นอันตรายได้ ดูเดฟอับราฮัมของการวิเคราะห์

อย่างไรก็ตามในท้ายที่สุดมาตรฐานได้รวมถึงการสร้างตัวสร้างการเคลื่อนย้ายโดยนัยและตัวดำเนินการกำหนดย้ายแม้ว่าจะมีข้อ จำกัด ที่ค่อนข้างชัดเจน:

ถ้านิยามของคลาส X ไม่ได้ประกาศตัวสร้างการย้ายอย่างชัดเจนตัวสร้างการย้ายจะถูกประกาศโดยปริยายว่าเป็นค่าเริ่มต้นก็ต่อเมื่อ
- X ไม่มีตัวสร้างการคัดลอกที่ผู้ใช้ประกาศไว้เท่านั้น
- X ไม่มีตัวดำเนินการกำหนดสำเนาที่ผู้ใช้ประกาศ ,
- X ไม่มีตัวดำเนินการ กำหนดการย้ายที่ผู้ใช้ประกาศ,
- X ไม่มีตัวทำลายที่ผู้ใช้ประกาศและ
- ตัวสร้างการย้ายจะไม่ถูกกำหนดโดยปริยายว่าถูกลบ

นั่นไม่ใช่ทั้งหมดที่มีอยู่ในเรื่องนี้ สามารถประกาศ ctor ได้ แต่ยังคงกำหนดเป็นลบ:

ตัวสร้างการคัดลอก / ย้ายที่ประกาศโดยนัยเป็นสมาชิกสาธารณะแบบอินไลน์ของคลาส ตัวสร้างการคัดลอก / ย้ายเริ่มต้นสำหรับคลาส X ถูกกำหนดให้เป็นลบ (8.4.3) ถ้า X มี:

- สมาชิกตัวแปรที่มีตัวสร้างที่สอดคล้องกันที่ไม่สำคัญและ X เป็นคลาสที่เหมือนสหภาพ -
สมาชิกข้อมูลที่ไม่คงที่ของคลาสประเภท M (หรืออาร์เรย์ของมัน) ที่ไม่สามารถคัดลอก / ย้ายได้เนื่องจากความละเอียดเกิน (13.3) ตามที่ นำไปใช้กับตัวสร้างที่สอดคล้องกันของ 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 ไม่ทำเพราะไม่ได้มาตรฐานในขณะที่ใช้งาน