วิธีการคัดลอกเมื่อผูกมัด?

ฉันกำลังสร้างคลาสของการผูกมัดประเภทเช่นตัวอย่างเล็ก ๆ ด้านล่าง ดูเหมือนว่าเมื่อการเชื่อมโยงสมาชิกฟังก์ชันแล้วตัวสร้างการคัดลอกจะถูกเรียกใช้ มีวิธีกำจัด call constructor ของการคัดลอกหรือไม่? ในตัวอย่างของเล่นของฉันด้านล่างเป็นที่ชัดเจนว่าฉันกำลังจัดการกับขมับเท่านั้นและดังนั้นจึงมี "ควร" (อาจไม่ได้ตามมาตรฐาน ตัวเลือกที่ดีที่สุดอันดับที่สองคือการคัดลอกตัวเลือกจะเป็นตัวสร้างการย้ายที่จะถูกเรียก แต่ไม่ใช่ในกรณีนี้

class test_class {
    private:
    int i = 5;
    public:
    test_class(int i) : i(i) {}
    test_class(const test_class& t) {
        i = t.i;
        std::cout << "Copy constructor"<< std::endl;
    }
    test_class(test_class&& t) {
        i = t.i;
        std::cout << "Move constructor"<< std::endl;
    }
    auto& increment(){
        i++;
        return *this;
    }
};
int main()
{
    //test_class a{7};
    //does not call copy constructor
    auto b = test_class{7};
    //calls copy constructor
    auto b2 = test_class{7}.increment();
    return 0;
}

แก้ไข: คำชี้แจงบางอย่าง 1. สิ่งนี้ไม่ได้ขึ้นอยู่กับระดับการปรับให้เหมาะสม 2. ในรหัสจริงของฉันฉันมีวัตถุที่ซับซ้อน (เช่นจัดสรรฮีป) มากกว่า ints

1. คำตอบบางส่วน (ไม่สร้างb2ขึ้น แต่เปลี่ยนโครงสร้างการคัดลอกเป็นการก่อสร้างแบบย้าย): คุณสามารถโอเวอร์โหลดincrementฟังก์ชันสมาชิกในหมวดค่าของอินสแตนซ์ที่เกี่ยวข้อง:

   auto& increment() & {
       i++;
       return *this;
   }
   
   auto&& increment() && {
       i++;
      return std::move(*this);
   }

   สาเหตุนี้

   auto b2 = test_class{7}.increment();

   เพื่อย้าย - สร้างb2เพราะtest_class{7}เป็นชั่วคราวและ&&เกินพิกัดของtest_class::incrementถูกเรียก

2. สำหรับการก่อสร้างในสถานที่จริง (เช่นไม่ใช่การก่อสร้างแบบเคลื่อนที่) คุณสามารถเปลี่ยนฟังก์ชั่นสมาชิกพิเศษและไม่ใช่สมาชิกพิเศษให้เป็นconstexprเวอร์ชั่นได้ จากนั้นคุณสามารถทำได้

   constexpr auto b2 = test_class{7}.increment();

   และคุณไม่ต้องย้ายหรือก่อสร้างคัดลอกที่จะจ่าย เห็นได้ชัดว่าเป็นไปได้สำหรับtest_classสถานการณ์ทั่วไป แต่ไม่ใช่สำหรับสถานการณ์ทั่วไปที่ไม่อนุญาตให้ใช้กับconstexprฟังก์ชั่นสมาชิก

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

วิธีที่ง่ายที่สุดน่าจะทำให้ตัวสร้างสำเนาถูกปรับให้เหมาะสมที่สุด การตั้งค่ามีการปรับค่าให้เหมาะสมโดยคอมไพเลอร์ซึ่งเป็นเพียงการปรับค่าstd::coutที่ไม่สามารถทำได้

test_class(const test_class& t) = default;

(หรือเพียงแค่ลบทั้งตัวคัดลอกและตัวสร้างการย้าย)

ตัวอย่างสด

เนื่องจากปัญหาของคุณเป็นแบบอ้างอิงการอ้างอิงอาจไม่ส่งคืนการอ้างอิงไปยังวัตถุถ้าคุณต้องการหยุดการคัดลอกด้วยวิธีนี้

  void increment();
};

auto b = test_class{7};//does not call copy constructor
b.increment();//does not call copy constructor

วิธีที่สามใช้พึ่งการคัดลอกในครั้งแรก - อย่างไรก็ตามวิธีนี้ต้องการการเขียนซ้ำหรือการห่อหุ้มของการดำเนินการเป็นหนึ่งฟังก์ชันและหลีกเลี่ยงปัญหาทั้งหมด (ฉันรู้ว่านี่อาจไม่ใช่สิ่งที่คุณต้องการ แต่อาจเป็น ทางออกสำหรับผู้ใช้รายอื่น):

auto b2 = []{test_class tmp{7}; tmp.increment().increment().increment(); return tmp;}(); //<-- b2 becomes 10 - copy constructor not called

วิธีที่สี่คือการใช้การย้ายแทนทั้งเรียกอย่างชัดเจน

auto b2 = std::move(test_class{7}.increment());

หรือเท่าที่เห็นในคำตอบนี้