std :: shared_ptr เป็นทางเลือกสุดท้าย?

ผมก็แค่ดู "Going พื้นเมือง 2012" std::shared_ptrลำธารและผมสังเกตเห็นการอภิปรายเกี่ยวกับ ฉันรู้สึกประหลาดใจเล็กน้อยที่ได้ยินมุมมองเชิงลบของ Bjarne std::shared_ptrและความคิดเห็นของเขาว่าควรใช้เป็น "ทางเลือกสุดท้าย" เมื่ออายุการใช้งานของวัตถุไม่แน่นอน (ซึ่งฉันเชื่อตามที่เขาพูด

ใครบ้างที่จะอธิบายสิ่งนี้ในเชิงลึกมากขึ้นอีกหน่อย? เราจะตั้งโปรแกรมโดยไม่ใช้std::shared_ptrและยังจัดการเวลาวัตถุได้อย่างปลอดภัยหรือไม่?

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

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

โลกที่ Bjarne อาศัยอยู่นั้นเป็น ... วิชาการเพื่อความต้องการในระยะที่ดีกว่า หากรหัสของคุณสามารถออกแบบและวางโครงสร้างให้วัตถุมีความสัมพันธ์เชิงลำดับชั้นสูงมากเช่นความสัมพันธ์ของการเป็นเจ้าของนั้นเข้มงวดและไม่ยอมให้รหัสไหลในทิศทางเดียว (จากระดับสูงถึงระดับต่ำ) และวัตถุจะพูดกับสิ่งที่ต่ำกว่า shared_ptrลำดับชั้นแล้วคุณจะไม่พบความจำเป็นมากสำหรับการ มันเป็นสิ่งที่คุณใช้ในโอกาสที่หายากเหล่านั้นซึ่งบางคนต้องฝ่าฝืนกฎ แต่มิฉะนั้นคุณสามารถติดทุกอย่างในvectors หรือโครงสร้างข้อมูลอื่น ๆ ที่ใช้ semantics ค่าและunique_ptrs สำหรับสิ่งที่คุณต้องจัดสรรโดยลำพัง

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

ในระบบเช่นนี้การถือพอยน์เตอร์พอยต์คือ ... ไม่อันตรายอย่างแน่นอน แต่มันทำให้เกิดคำถาม สิ่งที่ดีเกี่ยวกับshared_ptrมันคือการให้การรับประกันทางวากยสัมพันธ์ที่สมเหตุสมผลเกี่ยวกับอายุการใช้งานของวัตถุ มันหักได้ไหม? แน่นอน. แต่ผู้คนยังสามารถทำconst_castสิ่งต่าง ๆ ; การดูแลขั้นพื้นฐานและการให้อาหารshared_ptrควรมีคุณภาพชีวิตที่เหมาะสมสำหรับวัตถุที่ได้รับการจัดสรรซึ่งต้องมีการแบ่งปันความเป็นเจ้าของ

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

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

วิธีที่ปลอดภัยเพื่อความอยู่รอดเมื่อสภาวะของโลกไม่แน่นอน

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

ตอนนี้ที่ไม่ได้บอกว่าshared_ptrไม่สามารถจะตื้อ ; มันสามารถ โดยเฉพาะอย่างยิ่งก่อนunique_ptrมีหลายกรณีที่ฉันเพิ่งใช้boost::shared_ptrเพราะฉันต้องผ่านตัวชี้ RAII รอบ ๆ หรือใส่ไว้ในรายการ โดยไม่ต้องย้ายความหมายและunique_ptr, boost::shared_ptrเป็นทางออกที่แท้จริงเท่านั้น

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

std::shared_ptrผมไม่เชื่อว่าฉันเคยใช้

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

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

Nicol Bolas ให้ความเห็นว่า "หากวัตถุบางอย่างจับตัวชี้เปล่าและวัตถุนั้นตาย ... อุ๊ปส์" และ "วัตถุต้องตรวจสอบให้แน่ใจว่าวัตถุนั้นมีชีวิตตลอดชีวิตของวัตถุนั้นshared_ptrสามารถทำได้"

ฉันไม่ซื้อข้อโต้แย้งนั้น อย่างน้อยก็ไม่ได้shared_ptrแก้ปัญหานี้ เกี่ยวกับ:

• หากตารางแฮชบางส่วนจับวัตถุและแฮชโค้ดของวัตถุนั้นเปลี่ยนแปลง ... อุ๊ปส์
• ถ้าฟังก์ชั่นบางตัววนซ้ำเวกเตอร์และองค์ประกอบถูกแทรกลงในเวกเตอร์นั้น ... โอ๊ะโอ

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

วัตถุไม่ได้ "ตาย" บางส่วนของรหัสทำลายพวกเขา และโยนshared_ptrปัญหาแทนที่จะคิดออกสัญญาการโทรเป็นความปลอดภัยที่ผิดพลาด

ฉันไม่ต้องการคิดในแง่ที่แน่นอน (เช่น "วิธีสุดท้าย") แต่เกี่ยวข้องกับโดเมนปัญหา

C ++ สามารถเสนอวิธีการที่หลากหลายในการจัดการอายุการใช้งาน บางคนพยายามทำให้วัตถุอยู่ในสภาพที่เป็นกองซ้อน บางคนพยายามหลีกเลี่ยงข้อ จำกัด นี้ บางคนเป็น "ตัวอักษร" บางคนมีการประมาณ

ที่จริงคุณสามารถ:

1. ใช้ความหมายค่าบริสุทธิ์ ใช้งานได้กับวัตถุที่ค่อนข้างเล็กซึ่งสิ่งที่สำคัญคือ "ค่า" และไม่ใช่ "ตัวตน" ซึ่งคุณสามารถสันนิษฐานได้ว่าPersonมีสองคนที่เหมือนกันnameเป็นบุคคลเดียวกัน(ดีกว่า: เป็นตัวแทนของบุคคลเดียวกันสองคน ) อายุการใช้งานจะได้รับจากสแต็คเครื่องปลาย -essentially- เรื่อง deosn't ในการเขียนโปรแกรม (ตั้งแต่คนคือมันเป็นชื่อที่ไม่ว่าสิ่งที่Personจะแบกมัน)
2. ใช้วัตถุที่จัดสรรสแต็กและการอ้างอิงหรือพอยน์เตอร์ที่เกี่ยวข้อง: อนุญาตให้มีความหลากหลายและให้อายุการใช้งานของวัตถุ ไม่จำเป็นต้องใช้ "ตัวชี้อัจฉริยะ" เนื่องจากคุณมั่นใจได้ว่าไม่มีวัตถุใดที่สามารถ "ชี้" โดยโครงสร้างที่ปล่อยให้อยู่ในสแต็กนานกว่าวัตถุที่พวกเขาชี้ไปที่ (สร้างวัตถุขึ้นมาก่อน
3. ใช้วัตถุที่ได้รับการจัดสรรกองการจัดการกอง : นี่คือสิ่งที่ std :: vector และภาชนะทั้งหมดทำและวัดstd::unique_ptrทำ (คุณสามารถคิดว่ามันเป็นเวกเตอร์ที่มีขนาด 1) อีกครั้งคุณยอมรับวัตถุเริ่มมีอยู่ (และสิ้นสุดการดำรงอยู่ของพวกเขา) ก่อน (หลัง) โครงสร้างข้อมูลที่พวกเขาอ้างถึง

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

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

C ++ isteslf ไม่มีกลไกดั้งเดิมในการตรวจสอบเหตุการณ์นั้น ( while(are_they_needed)) ดังนั้นคุณต้องประมาณด้วย:

1. ใช้ความเป็นเจ้าของร่วม : อายุการใช้งานของวัตถุถูกผูกไว้กับ "ตัวนับอ้างอิง": ทำงานได้ถ้า "ความเป็นเจ้าของ" สามารถจัดลำดับชั้นได้ นี่คือสิ่งที่ std :: shared_ptr ทำ และ weak_ptr สามารถใช้เพื่อแบ่งลูป วิธีนี้ใช้เวลาส่วนใหญ่ แต่ล้มเหลวในการออกแบบขนาดใหญ่ที่นักออกแบบจำนวนมากทำงานในทีมที่แตกต่างกันและไม่มีเหตุผลที่ชัดเจน (สิ่งที่มาจากความต้องการค่อนข้าง) เกี่ยวกับผู้ที่เป็นเจ้าของสิ่งที่อับ (ตัวอย่างทั่วไปคือ ก่อนหน้าเนื่องจากการอ้างอิงถัดไปก่อนหน้าหรือถัดไปเป็นเจ้าของการอ้างอิงก่อนหน้าถัดไปหรือไม่ใน absebce ของความต้องการโซลูชัน tho จะเท่ากันและในโครงการขนาดใหญ่คุณมีความเสี่ยงที่จะรวมกัน)
2. ใช้กองเก็บขยะ : คุณไม่สนใจการแข่งขันตลอดชีวิต คุณเรียกใช้ตัวสะสมเป็นครั้งคราวและสิ่งที่ unreachabe ถูกพิจารณาว่า "ไม่ต้องการอีกต่อไป" และ ... ดี ... อะแฮ่ม ... ถูกทำลาย? สรุป? ?. แช่แข็ง มีนักสะสม GC จำนวนมาก แต่ฉันไม่เคยพบคนที่รู้ภาษา C ++ จริงๆ ส่วนใหญ่ของพวกเขาเพิ่มหน่วยความจำไม่สนใจเกี่ยวกับการทำลายวัตถุ
3. ใช้ตัวรวบรวมข้อมูลขยะ C ++ ที่มีอินเตอร์เฟสมาตรฐานวิธีการที่เหมาะสม ขอให้โชคดีที่ได้พบมัน

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

ตัวรวบรวมขยะมีค่าใช้จ่าย shared_ptr มีค่าน้อยลง Unique_ptr ยิ่งน้อยลงและวัตถุที่จัดการสแต็กมีน้อยมาก

เป็นshared_ptr"ทางเลือกสุดท้าย" หรือไม่? ไม่ไม่ใช่: ทางเลือกสุดท้ายคือนักสะสมขยะ shared_ptrเป็นทางเลือกstd::สุดท้าย แต่อาจเป็นทางออกที่ถูกต้องหากคุณอยู่ในสถานการณ์ที่ฉันอธิบาย

สิ่งหนึ่งที่เอ่ยโดย Herb Sutter ในเซสชั่นภายหลังคือทุกครั้งที่คุณคัดลอกจะshared_ptr<>มีการเพิ่ม / ลดลง interlocked ที่จะเกิดขึ้น บนโค้ดแบบมัลติเธรดบนระบบมัลติคอร์การซิงโครไนซ์หน่วยความจำไม่สำคัญ เมื่อกำหนดตัวเลือกจะเป็นการดีกว่าหากใช้ค่าสแต็กหรือ a unique_ptr<>และส่งผ่านการอ้างอิงหรือพอยน์เตอร์พอยน์เตอร์

ฉันจำไม่ได้ว่า "Resort" สุดท้ายเป็นคำที่แน่นอนที่เขาใช้หรือไม่ แต่ฉันเชื่อว่าความหมายที่แท้จริงของสิ่งที่เขาพูดนั้นเป็น "ตัวเลือก" สุดท้าย: ได้รับเงื่อนไขการเป็นเจ้าของชัดเจน unique_ptr, weak_ptr, shared_ptr และแม้แต่พอยน์เตอร์พอยน์เตอร์ก็มีที่อยู่ของพวกเขา

สิ่งหนึ่งที่พวกเขาเห็นพ้องต้องกันก็คือพวกเรา (นักพัฒนาผู้แต่งหนังสือ ฯลฯ ) ทั้งหมดอยู่ใน "ระยะการเรียนรู้" ของ C ++ 11 และมีการกำหนดรูปแบบและสไตล์

ยกตัวอย่างเช่น Herb อธิบายเราควรคาดหวังว่าหนังสือรุ่นใหม่ของ C ++ บางเล่มเช่นEffective C ++ (Meyers) และC ++ มาตรฐานการเข้ารหัส (Sutter & Alexandrescu) สองสามปีในขณะที่ประสบการณ์ของอุตสาหกรรมและแนวปฏิบัติที่ดีที่สุดกับ C ++ 11 กะทะ

ฉันคิดว่าสิ่งที่เขาทำคือมันเป็นเรื่องธรรมดาที่ทุกคนจะเขียน shared_ptr เมื่อใดก็ตามที่พวกเขาอาจจะเขียนตัวชี้มาตรฐาน (เช่นการทดแทนทั่วโลก) และมันถูกใช้เป็น Cop-out แทนที่จะออกแบบจริงหรืออย่างน้อย การวางแผนสำหรับการสร้างวัตถุและการลบ

สิ่งอื่น ๆ ที่ผู้คนลืม (นอกเหนือจากการล็อก / อัปเดต / ปลดล็อกคอขวดที่กล่าวถึงในเนื้อหาด้านบน) คือ shared_ptr เพียงอย่างเดียวไม่สามารถแก้ปัญหาวงจรได้ คุณยังคงสามารถรั่วไหลของทรัพยากรด้วย shared_ptr:

วัตถุ A มีตัวชี้ที่ใช้ร่วมกันไปยังวัตถุ A วัตถุ B อื่นสร้าง A1 และ A2 และกำหนด a1.otherA = a2; และ a2.otherA = a1; ตอนนี้ตัวชี้ที่ใช้ร่วมกันของวัตถุ B ที่ใช้สร้าง a1, a2 ออกไปนอกขอบเขต (พูดที่ท้ายฟังก์ชั่น) ตอนนี้คุณมีการรั่วไหล - ไม่มีใครอ้างถึง a1 และ a2 แต่พวกเขาอ้างถึงกันและกันดังนั้นจำนวนการอ้างอิงของพวกเขาจึงเป็น 1 เสมอและคุณรั่วไหล

นั่นคือตัวอย่างง่ายๆเมื่อสิ่งนี้เกิดขึ้นในโค้ดจริงมันมักจะเกิดขึ้นในรูปแบบที่ซับซ้อน มีวิธีแก้ปัญหาที่มี weak_ptr แต่ตอนนี้มีคนจำนวนมากเพียงแค่ทำ shared_ptr ทุกที่และไม่รู้แม้แต่ปัญหาการรั่วไหลหรือแม้แต่ของ weak_ptr

เพื่อสรุป: ฉันคิดว่าความคิดเห็นอ้างอิงโดย OP ต้มลงไปนี้:

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

แก้ไข: แม้ว่านั่นหมายถึง "ไม่ทราบฉันต้องใช้ shared_ptr" คุณยังคงคิดอยู่และตั้งใจทำเช่นนั้น

ฉันจะตอบจากประสบการณ์ของฉันกับ Objective-C ซึ่งเป็นภาษาที่มีการอ้างอิงและนับจำนวนวัตถุทั้งหมดในฮีป เนื่องจากมีวิธีหนึ่งในการจัดการวัตถุสิ่งต่าง ๆ จึงง่ายขึ้นสำหรับโปรแกรมเมอร์ ที่ได้รับอนุญาตสำหรับกฎมาตรฐานที่จะกำหนดว่าเมื่อปฏิบัติตามรับประกันความแข็งแกร่งของรหัสและไม่มีการรั่วไหลของหน่วยความจำ นอกจากนี้ยังเป็นไปได้ที่การเพิ่มประสิทธิภาพคอมไพเลอร์ที่ชาญฉลาดจะเกิดขึ้นเช่น ARC ล่าสุด (การนับการอ้างอิงอัตโนมัติ)

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

ฉันจะพยายามตอบคำถาม:

เราจะเขียนโปรแกรมโดยไม่ใช้ std :: shared_ptr และจัดการอายุการใช้งานของวัตถุอย่างปลอดภัยได้อย่างไร?

C ++ มีหลายวิธีในการทำหน่วยความจำเช่น:

1. ใช้struct A { MyStruct s1,s2; };แทน shared_ptr ในขอบเขตของคลาส สิ่งนี้มีไว้สำหรับโปรแกรมเมอร์ขั้นสูงเนื่องจากต้องการให้คุณเข้าใจว่าการทำงานของการพึ่งพาและต้องการความสามารถในการควบคุมการพึ่งพามากพอที่จะ จำกัด การพึ่งพาต้นไม้ ลำดับของคลาสในไฟล์ส่วนหัวเป็นสิ่งสำคัญของสิ่งนี้ ดูเหมือนว่าการใช้งานนี้มีอยู่ทั่วไปกับชนิด native buildin c ++ แต่การใช้งานกับคลาสที่โปรแกรมเมอร์กำหนดไว้ดูเหมือนว่าจะใช้น้อยลงเนื่องจากการพึ่งพาและลำดับของปัญหาในชั้นเรียนเหล่านี้ วิธีนี้ยังมีปัญหากับขนาดของ โปรแกรมเมอร์เห็นปัญหาในเรื่องนี้เป็นข้อกำหนดในการใช้การประกาศล่วงหน้าหรือ #includes ที่ไม่จำเป็นและทำให้โปรแกรมเมอร์จำนวนมากกลับไปใช้วิธีแก้ปัญหาที่ต่ำกว่าของพอยน์เตอร์และในภายหลังเพื่อ shared_ptr
2. ใช้MyClass &find_obj(int i);โคลน + () shared_ptr<MyClass> create_obj(int i);แทน โปรแกรมเมอร์หลายคนต้องการสร้างโรงงานเพื่อสร้างวัตถุใหม่ shared_ptr เหมาะสำหรับการใช้งานประเภทนี้ ปัญหาคือว่ามันถือว่าโซลูชั่นการจัดการหน่วยความจำที่ซับซ้อนโดยใช้การจัดสรรร้านค้าฮีป / ฟรีแทนสแต็คง่ายขึ้นหรือการแก้ปัญหาตามวัตถุ ลำดับชั้นของคลาส C ++ ที่ดีรองรับโครงร่างการจัดการหน่วยความจำทั้งหมดไม่ใช่แค่หนึ่งในนั้น โซลูชันอ้างอิงที่อ้างอิงสามารถใช้งานได้หากวัตถุที่ส่งคืนถูกเก็บไว้ภายในวัตถุที่มีอยู่แทนที่จะใช้ตัวแปรขอบเขตของฟังก์ชันในเครื่อง ควรหลีกเลี่ยงการส่งผ่านความเป็นเจ้าของจากโรงงานไปยังรหัสผู้ใช้ การคัดลอกวัตถุหลังจากใช้ find_obj () เป็นวิธีที่ดีในการจัดการมัน - ตัวสร้างสำเนาปกติและตัวสร้างแบบปกติ (ของคลาสอื่น) ด้วยพารามิเตอร์ refrerence หรือ clone () สำหรับวัตถุ polymorphic สามารถจัดการได้
3. ใช้การอ้างอิงแทนตัวชี้หรือ shared_ptrs ทุกคลาส c ++ มีคอนสตรัคเตอร์และสมาชิกข้อมูลอ้างอิงแต่ละคนจะต้องเริ่มต้น การใช้งานนี้สามารถหลีกเลี่ยงการใช้พอยน์เตอร์และ shared_ptrs จำนวนมาก คุณเพียงแค่ต้องเลือกว่าหน่วยความจำของคุณอยู่ในวัตถุหรือภายนอกและเลือกโซลูชัน struct หรือโซลูชันอ้างอิงตามการตัดสินใจ ปัญหาเกี่ยวกับการแก้ปัญหานี้มักจะเกี่ยวข้องกับการหลีกเลี่ยงพารามิเตอร์คอนสตรัคเตอร์ซึ่งเป็นเรื่องปกติ แต่การปฏิบัติที่เป็นปัญหาและเข้าใจผิดว่าควรออกแบบอินเตอร์เฟสสำหรับคลาส