การส่งพอยน์เตอร์ที่ใช้ร่วมกันเป็นอาร์กิวเมนต์

ถ้าฉันประกาศว่าวัตถุที่อยู่ในตัวชี้ที่ใช้ร่วมกัน:

std::shared_ptr<myClass> myClassObject(new myClass());

จากนั้นฉันต้องการส่งต่อเป็นอาร์กิวเมนต์ให้กับวิธีการ:

DoSomething(myClassObject);

//the called method
void DoSomething(std::shared_ptr<myClass> arg1)
{
   arg1->someField = 4;
}

ข้างต้นเพียงแค่เพิ่มจำนวนการอ้างอิงของ shared_pt และทุกอย่างจะดี? หรือไม่ทิ้งตัวชี้ห้อย?

คุณยังควรทำสิ่งนี้หรือไม่:

DoSomething(myClassObject.Get());

void DoSomething(std::shared_ptr<myClass>* arg1)
{
   (*arg1)->someField = 4;
}

ฉันคิดว่าวิธีที่ 2 อาจมีประสิทธิภาพมากกว่าเพราะต้องคัดลอกที่อยู่ 1 รายการเท่านั้น (ตรงข้ามกับตัวชี้อัจฉริยะทั้งหมด) แต่วิธีที่ 1 ดูเหมือนจะอ่านได้มากกว่าและฉันไม่คาดว่าจะมีการ จำกัด ประสิทธิภาพการทำงาน ฉันแค่อยากให้แน่ใจว่าไม่มีอะไรอันตรายเกี่ยวกับเรื่องนี้

ขอขอบคุณ.

ฉันต้องการส่งตัวชี้ที่ใช้ร่วมกันไปยังฟังก์ชัน คุณสามารถช่วยฉันด้วย?

ได้เลยฉันช่วยคุณได้ ฉันถือว่าคุณมีความเข้าใจเกี่ยวกับความหมายความเป็นเจ้าของใน C ++ เป็นเช่นนั้นจริงหรือ?

ใช่ฉันสบายใจพอสมควรกับเรื่องนี้

ดี.

โอเคฉันคิดได้แค่สองเหตุผลที่จะshared_ptrโต้แย้ง:

1. ฟังก์ชั่นต้องการแบ่งปันความเป็นเจ้าของวัตถุ
2. ฟังก์ชั่นนี้ทำงานบางอย่างที่ทำงานเฉพาะกับshared_ptrs

สนใจอันไหน

ฉันกำลังมองหาคำตอบทั่วไปดังนั้นฉันจึงสนใจทั้งสองอย่าง ฉันอยากรู้ว่าคุณหมายถึงอะไรในกรณีที่ 2

ตัวอย่างของฟังก์ชันดังกล่าว ได้แก่ ตัวstd::static_pointer_castเปรียบเทียบแบบกำหนดเองหรือเพรดิเคต ตัวอย่างเช่นหากคุณต้องการค้นหา shared_ptr ที่ไม่ซ้ำกันทั้งหมดจากเวกเตอร์คุณต้องมีเพรดิเคตดังกล่าว

อ่าเมื่อฟังก์ชันต้องจัดการตัวชี้อัจฉริยะเองจริงๆ

ตรง

ในกรณีนั้นฉันคิดว่าเราควรผ่านการอ้างอิง

ใช่. และถ้ามันไม่เปลี่ยนตัวชี้คุณต้องส่งผ่านการอ้างอิง const ไม่จำเป็นต้องคัดลอกเนื่องจากคุณไม่จำเป็นต้องมีส่วนร่วมในการเป็นเจ้าของ นั่นคือสถานการณ์อื่น ๆ

ตกลงเข้าใจแล้ว เรามาพูดถึงสถานการณ์อื่น ๆ

คนที่คุณเป็นเจ้าของร่วมกัน? ตกลง. คุณเป็นเจ้าของร่วมกันได้shared_ptrอย่างไร?

โดยการคัดลอก.

จากนั้นฟังก์ชันจะต้องทำสำเนาของ a shared_ptrถูกต้องหรือไม่?

เห็นได้ชัด. ดังนั้นฉันจึงส่งต่อโดยการอ้างอิงถึง const และคัดลอกไปยังตัวแปรท้องถิ่น?

ไม่นั่นเป็นการมองโลกในแง่ร้าย หากส่งผ่านโดยการอ้างอิงฟังก์ชันจะไม่มีทางเลือกอื่นนอกจากทำสำเนาด้วยตนเอง หากมีการส่งผ่านค่าคอมไพลเลอร์จะเลือกตัวเลือกที่ดีที่สุดระหว่างสำเนาและการย้ายและดำเนินการโดยอัตโนมัติ ผ่านไปเลยค่า

จุดดี. ฉันต้องจำไว้ว่าบทความ " ต้องการความเร็วหรือไม่ผ่านค่า " บ่อยขึ้น

เดี๋ยวก่อนจะเกิดอะไรขึ้นถ้าฟังก์ชันเก็บshared_ptrตัวแปรในสมาชิกเช่น? จะไม่ทำสำเนาซ้ำซ้อน?

ฟังก์ชันสามารถย้ายshared_ptrอาร์กิวเมนต์ไปยังที่เก็บข้อมูลได้ การย้าย a shared_ptrมีราคาถูกเนื่องจากไม่เปลี่ยนแปลงการนับอ้างอิงใด ๆ

อ่าความคิดที่ดี

แต่ฉันกำลังคิดถึงสถานการณ์ที่สาม: จะเกิดอะไรขึ้นถ้าคุณไม่ต้องการที่จะจัดการshared_ptrหรือร่วมเป็นเจ้าของ?

ในกรณีshared_ptrนั้นไม่เกี่ยวข้องกับฟังก์ชันนี้โดยสิ้นเชิง หากคุณต้องการจัดการพอยน์ตี้ให้ใช้พอยน์เตอร์แล้วปล่อยให้ผู้โทรเลือกว่าต้องการความหมายของการเป็นเจ้าของ

และฉันควรใช้ pointee โดยอ้างอิงหรือตามค่า?

ใช้กฎตามปกติ ตัวชี้อัจฉริยะจะไม่เปลี่ยนแปลงอะไร

ส่งผ่านค่าถ้าฉันจะคัดลอกส่งต่อโดยอ้างอิงหากฉันต้องการหลีกเลี่ยงสำเนา

ขวา.

อืม. ฉันคิดว่าคุณลืมสถานการณ์อื่นไปแล้ว จะเป็นอย่างไรหากฉันต้องการร่วมเป็นเจ้าของ แต่ขึ้นอยู่กับเงื่อนไขบางประการเท่านั้น

อากรณีขอบที่น่าสนใจ ฉันไม่คาดคิดว่าจะเกิดขึ้นบ่อยๆ แต่เมื่อเกิดขึ้นคุณสามารถส่งผ่านค่าและละเว้นสำเนาได้หากไม่ต้องการหรือส่งต่อโดยอ้างอิงและทำสำเนาหากต้องการ

ฉันเสี่ยงต่อการทำสำเนาซ้ำซ้อนหนึ่งชุดในตัวเลือกแรกและสูญเสียโอกาสในการย้ายครั้งที่สอง ฉันไม่สามารถกินเค้กได้หรือไม่?

หากคุณอยู่ในสถานการณ์ที่มีความสำคัญมากคุณสามารถระบุโอเวอร์โหลดได้สองค่าโดยตัวหนึ่งใช้การอ้างอิง const lvalue และอีกอันใช้การอ้างอิง rvalue หนึ่งสำเนาการเคลื่อนไหวอื่น ๆ เทมเพลตฟังก์ชันการส่งต่อที่สมบูรณ์แบบเป็นอีกทางเลือกหนึ่ง

ฉันคิดว่ามันครอบคลุมสถานการณ์ที่เป็นไปได้ทั้งหมด ขอบคุณมาก.

ฉันคิดว่าผู้คนกลัวการใช้ตัวชี้ดิบเป็นพารามิเตอร์ของฟังก์ชันโดยไม่จำเป็น หากฟังก์ชันไม่ได้จัดเก็บตัวชี้หรือส่งผลต่ออายุการใช้งานตัวชี้ดิบจะทำงานเช่นกันและแสดงถึงตัวส่วนร่วมที่ต่ำที่สุด ลองพิจารณาตัวอย่างเช่นว่าคุณจะส่งผ่านunique_ptrไปยังฟังก์ชันที่รับshared_ptrเป็นพารามิเตอร์ได้อย่างไรโดยใช้ค่าหรือโดยการอ้างอิง const?

void DoSomething(myClass * p);

DoSomething(myClass_shared_ptr.get());
DoSomething(myClass_unique_ptr.get());

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

ใช่แนวคิดทั้งหมดเกี่ยวกับ shared_ptr <> คือหลายอินสแตนซ์สามารถเก็บตัวชี้ดิบเดียวกันได้และหน่วยความจำพื้นฐานจะถูกปล่อยให้เป็นอิสระก็ต่อเมื่อมีการทำลายอินสแตนซ์สุดท้ายของ shared_ptr <>

ฉันจะหลีกเลี่ยงตัวชี้ไปที่ shared_ptr <> เนื่องจากมันเอาชนะจุดประสงค์ในขณะนี้คุณกำลังจัดการกับ raw_pointers อีกครั้ง

Passing-by-value ในตัวอย่างแรกของคุณปลอดภัย แต่มีสำนวนที่ดีกว่า ผ่านการอ้างอิง const เมื่อเป็นไปได้ - ฉันจะตอบว่าใช่แม้ว่าจะจัดการกับตัวชี้อัจฉริยะก็ตาม ตัวอย่างที่สองของคุณจะไม่เสียว่า !???แต่มันก็มาก งี่เง่าไม่ทำอะไรให้สำเร็จและเอาชนะส่วนหนึ่งของตัวชี้ที่ชาญฉลาดและจะทำให้คุณอยู่ในโลกแห่งความเจ็บปวดเมื่อคุณพยายามลดทอนและปรับเปลี่ยนสิ่งต่างๆ

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

ในกรณีนี้คุณกำลังส่งอ็อบเจ็กต์ไปยังฟังก์ชันโดยรับประกันว่าคุณไม่ได้แก้ไข (พูดถึง shared_ptr ไม่ใช่อ็อบเจ็กต์ที่เป็นเจ้าของ)

สำนวนที่จะแสดงสิ่งนี้คือผ่าน: const ref เช่นนั้น

void DoSomething(const std::shared_ptr<myClass>& arg)

ในทำนองเดียวกันคุณรับรองผู้ใช้ฟังก์ชันของคุณว่าคุณไม่ได้เพิ่มเจ้าของรายอื่นในรายชื่อเจ้าของตัวชี้ดิบ อย่างไรก็ตามคุณยังคงมีความเป็นไปได้ที่จะแก้ไขวัตถุที่อยู่ข้างใต้ที่ชี้โดยตัวชี้ดิบ

CAVEAT: ซึ่งหมายความว่าหากมีคนโทรshared_ptr::resetมาก่อนที่คุณจะเรียกใช้ฟังก์ชันของคุณและในขณะนั้นเป็น shared_ptr สุดท้ายที่เป็นเจ้าของ raw_ptr วัตถุของคุณจะถูกทำลายและฟังก์ชันของคุณจะจัดการกับตัวชี้ห้อยไปยังวัตถุที่ถูกทำลาย อันตรายมาก!!!