วิธี“ คืนวัตถุ” ใน C ++ ได้อย่างไร

ฉันรู้ว่าชื่อฟังดูคุ้นหูเพราะมีคำถามคล้าย ๆ กันหลายอย่าง แต่ฉันขอปัญหาที่แตกต่าง (ฉันรู้ถึงความแตกต่างระหว่างการมีสิ่งของในกองซ้อน

ใน Java ฉันสามารถกลับไปอ้างอิงถึงวัตถุ "ท้องถิ่น"

public Thing calculateThing() {
    Thing thing = new Thing();
    // do calculations and modify thing
    return thing;
}

ใน C ++ เพื่อทำสิ่งที่คล้ายกันฉันมี 2 ตัวเลือก

(1) ฉันสามารถใช้การอ้างอิงเมื่อใดก็ตามที่ฉันต้องการ "ส่งคืน" วัตถุ

void calculateThing(Thing& thing) {
    // do calculations and modify thing
}

จากนั้นใช้มันเช่นนี้

Thing thing;
calculateThing(thing);

(2) หรือฉันสามารถคืนค่าตัวชี้ไปยังวัตถุที่ถูกจัดสรรแบบไดนามิก

Thing* calculateThing() {
    Thing* thing(new Thing());
    // do calculations and modify thing
    return thing;
}

จากนั้นใช้มันเช่นนี้

Thing* thing = calculateThing();
delete thing;

การใช้วิธีแรกฉันจะไม่ต้องเพิ่มหน่วยความจำด้วยตนเอง แต่สำหรับฉันมันทำให้โค้ดอ่านยาก ปัญหาเกี่ยวกับแนวทางที่สองคือฉันต้องจำไว้delete thing;ซึ่งไม่ได้ดูดีนัก ฉันไม่ต้องการคืนค่าที่คัดลอกเพราะไม่มีประสิทธิภาพ (ฉันคิดว่า) ดังนั้นคำถามมาที่นี่

• มีวิธีที่สาม (ไม่ต้องการคัดลอกค่า) หรือไม่
• มีปัญหาใดไหมถ้าฉันติดกับวิธีแก้ปัญหาแรก?
• ฉันควรใช้โซลูชันที่สองเมื่อใดและเพราะเหตุใด

ฉันไม่ต้องการส่งคืนค่าที่คัดลอกเนื่องจากไม่มีประสิทธิภาพ

พิสูจน์สิ.

ค้นหา RVO และ NRVO และใน C ++ 0x move-semantics ในกรณีส่วนใหญ่ใน C ++ 03 พารามิเตอร์ out เป็นวิธีที่ดีในการทำให้โค้ดของคุณน่าเกลียดและใน C ++ 0x คุณต้องทำร้ายตัวเองด้วยการใช้พารามิเตอร์ out

เพียงแค่เขียนโค้ดที่สะอาดส่งคืนตามค่า หากประสิทธิภาพเป็นปัญหาให้โปรไฟล์ (หยุดเดา) และค้นหาสิ่งที่คุณสามารถทำได้เพื่อแก้ไข เป็นไปได้ว่าจะไม่คืนสิ่งต่าง ๆ จากฟังก์ชั่น

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

หากคุณต้องการใช้การจัดสรรแบบไดนามิกอย่างน้อยที่สุดที่สามารถทำได้คือวางไว้ในตัวชี้สมาร์ท (สิ่งนี้ควรทำตลอดเวลาอยู่แล้ว) จากนั้นคุณไม่ต้องกังวลเกี่ยวกับการลบสิ่งต่าง ๆ สิ่งต่าง ๆ ปลอดภัยยกเว้น ฯลฯ ปัญหาเดียวคือมันน่าจะช้ากว่าคืนค่า!

เพียงแค่สร้างวัตถุและคืนมัน

Thing calculateThing() {
    Thing thing;
    // do calculations and modify thing
     return thing;
}

ฉันคิดว่าคุณจะทำสิ่งที่ดีหากคุณลืมเกี่ยวกับการปรับให้เหมาะสมและเพียงแค่เขียนโค้ดที่สามารถอ่านได้ (คุณจะต้องเรียกใช้ profiler ในภายหลัง - แต่ไม่ต้องปรับแต่งล่วงหน้า)

เพียงแค่คืนค่าวัตถุเช่นนี้:

Thing calculateThing() 
{
   Thing thing();
   // do calculations and modify thing
   return thing;
}

สิ่งนี้จะเรียกใช้ตัวสร้างการคัดลอกในสิ่งต่าง ๆ ดังนั้นคุณอาจต้องการดำเนินการสิ่งนั้นเอง แบบนี้:

Thing(const Thing& aThing) {}

สิ่งนี้อาจทำงานช้าลงเล็กน้อย แต่อาจไม่เป็นปัญหาเลย

ปรับปรุง

คอมไพเลอร์อาจจะปรับการเรียกไปยังตัวสร้างการคัดลอกดังนั้นจึงไม่มีค่าใช้จ่ายเพิ่มเติม (เหมือน Dreamlax ชี้ให้เห็นในความคิดเห็น)

คุณลองใช้พอยน์เตอร์อัจฉริยะ (ถ้าเป็นสิ่งที่มีขนาดใหญ่และหนักมาก) เช่น auto_ptr:

std::auto_ptr<Thing> calculateThing()
{
  std::auto_ptr<Thing> thing(new Thing);
  // .. some calculations
  return thing;
}


// ...
{
  std::auto_ptr<Thing> thing = calculateThing();
  // working with thing

  // auto_ptr frees thing 
}

วิธีหนึ่งที่รวดเร็วในการพิจารณาว่าตัวสร้างสำเนากำลังถูกเรียกหรือไม่คือการเพิ่มการบันทึกลงในตัวสร้างสำเนาของคลาสของคุณ:

MyClass::MyClass(const MyClass &other)
{
    std::cout << "Copy constructor was called" << std::endl;
}

MyClass someFunction()
{
    MyClass dummy;
    return dummy;
}

โทรsomeFunction; จำนวนของ "ตัวสร้างการคัดลอกเรียกว่า" บรรทัดที่คุณจะได้รับจะแตกต่างกันระหว่าง 0, 1 และ 2 หากคุณไม่ได้รับแล้วคอมไพเลอร์ของคุณได้เพิ่มประสิทธิภาพการคืนค่าออก (ซึ่งได้รับอนุญาตให้ทำ) ถ้าคุณได้รับไม่ได้รับ 0 และตัวสร้างสำเนาของคุณมีราคาแพงขันแล้วค้นหาวิธีทางเลือกที่จะกลับมาจากอินสแตนซ์ฟังก์ชั่นของคุณ

ประการแรกคุณมีข้อผิดพลาดในรหัสคุณหมายถึงการที่จะมีและมีเพียงThing *thing(new Thing());return thing;

• shared_ptr<Thing>ใช้ ลองอีกครั้งเพราะมันเป็นตัวชี้ มันจะถูกลบสำหรับคุณเมื่อการอ้างอิงล่าสุดของสิ่งที่Thingมีอยู่นอกขอบเขต
• วิธีแก้ปัญหาแรกนั้นพบได้บ่อยในห้องสมุดไร้เดียงสา มันมีประสิทธิภาพบางอย่างและค่าใช้จ่ายในการสร้างประโยคหลีกเลี่ยงถ้าเป็นไปได้
• ใช้วิธีแก้ไขปัญหาที่สองเฉพาะในกรณีที่คุณสามารถรับประกันว่าจะไม่มีข้อยกเว้นหรือเมื่อประสิทธิภาพการทำงานมีความสำคัญอย่างยิ่ง (คุณจะเชื่อมต่อกับ C หรือแอสเซมบลีก่อนหน้านี้แม้จะเกี่ยวข้อง)

ฉันแน่ใจว่าผู้เชี่ยวชาญ C ++ จะมาพร้อมกับคำตอบที่ดีกว่า แต่โดยส่วนตัวแล้วฉันชอบแนวทางที่สอง การใช้สมาร์ทพอยน์เตอร์ช่วยในเรื่องของการลืมdeleteและอย่างที่คุณพูดมันดูสะอาดกว่าการสร้างวัตถุก่อนมือ (และยังคงต้องลบมันถ้าคุณต้องการจัดสรรมันบนกอง)