ทำไมตัวชี้สมาร์ทที่มีการอ้างอิงจำนวนมากถึงได้รับความนิยม?

อย่างที่ฉันเห็นตัวชี้สมาร์ทถูกใช้อย่างกว้างขวางในโครงการ C ++ ในโลกแห่งความเป็นจริง

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

ทำไมตัวชี้ที่ใช้ร่วมกันรับความนิยมมากกว่าการบูรณาการเก็บขยะที่เหมาะสมเช่นBoehm GC ? (หรือคุณเห็นด้วยเลยว่ามันได้รับความนิยมมากกว่า GCs จริงหรือไม่)

ฉันรู้เกี่ยวกับข้อดีสองประการของ GCs ทั่วไปมากกว่าการนับการอ้างอิง:

• ขั้นตอนวิธี GC ธรรมดาไม่มีปัญหากับการอ้างอิงรอบ
• การนับการอ้างอิงโดยทั่วไปจะช้ากว่า GC ที่เหมาะสม

อะไรคือสาเหตุของการใช้ตัวชี้สมาร์ทนับการอ้างอิง?

ข้อดีบางประการของการอ้างอิงนับมากกว่าการรวบรวมขยะ:

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

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

3. ที่เรียบง่าย สามารถอธิบายการนับการอ้างอิงในไม่กี่นาทีและนำไปใช้ในหนึ่งหรือสองชั่วโมง นักสะสมขยะโดยเฉพาะที่มีประสิทธิภาพเหมาะสมมีความซับซ้อนอย่างมากและมีคนไม่มากนักที่เข้าใจพวกเขา

4. มาตรฐาน. C ++ รวมถึงการนับการอ้างอิง (ผ่าน shared_ptr) และเพื่อน ๆ ใน STL ซึ่งหมายความว่าโปรแกรมเมอร์ C ++ ส่วนใหญ่คุ้นเคยกับมันและรหัส C ++ ส่วนใหญ่จะใช้งานได้ ไม่มีตัวรวบรวมขยะ C ++ มาตรฐานใด ๆ ซึ่งหมายความว่าคุณต้องเลือกอย่างใดอย่างหนึ่งและหวังว่ามันจะทำงานได้ดีสำหรับกรณีการใช้งานของคุณ - และหากไม่เป็นเช่นนั้นก็เป็นปัญหาของคุณที่จะต้องแก้ไขไม่ใช่ภาษา

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

สำหรับประสิทธิภาพฉันไม่เคยมีปัญหากับประสิทธิภาพการนับการอ้างอิง ฉันมีปัญหาเกี่ยวกับประสิทธิภาพของการรวบรวมขยะโดยเฉพาะอย่างยิ่งการสุ่มแช่แข็งที่ GC สามารถเกิดขึ้นได้ซึ่งวิธีแก้ปัญหาเดียว ("ไม่จัดสรรวัตถุ") อาจได้รับการแนะนำใหม่เป็น "อย่าใช้ GC" .

เพื่อให้ได้ประสิทธิภาพที่ดีจาก GC นั้น GC จำเป็นต้องสามารถย้ายวัตถุในหน่วยความจำ ในภาษาเช่น C ++ ที่คุณสามารถโต้ตอบโดยตรงกับตำแหน่งหน่วยความจำนี่เป็นไปไม่ได้เลยทีเดียว (Microsoft C ++ / CLR จะไม่นับเพราะแนะนำไวยากรณ์ใหม่สำหรับพอยน์เตอร์ที่มีการจัดการโดย GC ดังนั้นจึงเป็นภาษาอื่นที่มีประสิทธิภาพ)

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

GC ที่ดีและได้รับการปรับแต่งนั้นสามารถเป็นสิ่งที่ยอดเยี่ยม แต่ในภาษาอย่าง C ++ กำไรจะน้อยที่สุดและค่าใช้จ่ายมักจะไม่คุ้มค่า

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

ดูเพิ่มเติมคำตอบของฉันคำถามที่เกี่ยวข้องมากกว่าใน StackOverflow

อย่างที่ฉันเห็นตัวชี้สมาร์ทถูกใช้อย่างกว้างขวางในโครงการ C ++ ในโลกแห่งความเป็นจริง

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

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

นั่นเป็นความคิดที่ไม่ดีเพราะคุณยังต้องกังวลกับวงจร

ทำไมพอยน์เตอร์ที่ใช้ร่วมกันจึงได้รับความนิยมมากกว่าการรวมตัวรวบรวมขยะที่เหมาะสมเช่น Boehm GC (หรือคุณเห็นด้วยเลยว่ามันได้รับความนิยมมากกว่า GCs จริงหรือไม่)

โอ้ว้าวมีหลายสิ่งที่คุณคิดผิด:

1. Boehm's GC ไม่ใช่ GC ที่ "เหมาะสม" ในแง่ของคำศัพท์ มันช่างน่ากลัวจริงๆ มันเป็นแบบอนุรักษ์นิยมดังนั้นจึงรั่วไหลและไม่มีประสิทธิภาพโดยการออกแบบ ดู: http://flyingfrogblog.blogspot.co.uk/search/label/boehm

2. พอยน์เตอร์ที่ใช้ร่วมกันนั้นไม่มีความใกล้เคียงกับความนิยมเท่าที่ GC เพราะนักพัฒนาส่วนใหญ่ใช้ภาษา GC'd ในขณะนี้และไม่ต้องการพอยน์เตอร์ที่ใช้ร่วมกัน เพียงดูที่ Java และ Javascript ในตลาดงานเปรียบเทียบกับ C ++

3. ดูเหมือนว่าคุณจะถูก จำกัด การพิจารณาให้กับ C ++ เพราะฉันคิดว่าคุณคิดว่า GC เป็นปัญหาทางสัมผัส มันไม่ใช่ ( วิธีเดียวที่จะได้ GC ที่เหมาะสมคือการออกแบบภาษาและ VM ตั้งแต่ต้น) ดังนั้นคุณจึงแนะนำอคติการเลือก ผู้ที่ต้องการการเก็บขยะที่เหมาะสมไม่ติดกับ C ++

อะไรคือสาเหตุของการใช้ตัวชี้สมาร์ทนับการอ้างอิง?

คุณถูก จำกัด ไว้ที่ C ++ แต่หวังว่าคุณจะมีการจัดการหน่วยความจำอัตโนมัติ

ใน MacOS X และ iOS และกับนักพัฒนาที่ใช้ Objective-C หรือ Swift การนับการอ้างอิงเป็นที่นิยมเนื่องจากมีการจัดการโดยอัตโนมัติและการใช้การรวบรวมขยะลดลงอย่างมากเนื่องจาก Apple ไม่รองรับอีกต่อไป (ฉันบอกว่าแอปที่ใช้ การรวบรวมขยะจะแตกในเวอร์ชัน MacOS X ถัดไปและการรวบรวมขยะไม่เคยนำมาใช้ใน iOS) ฉันสงสัยอย่างจริงจังจริง ๆ ว่ามีซอฟต์แวร์จำนวนมากที่เคยใช้การรวบรวมขยะเมื่อพร้อมใช้งาน

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

สิ่งแรกที่นักพัฒนา MacOS X หรือ iOS เรียนรู้คือวิธีจัดการรอบการอ้างอิงดังนั้นจึงไม่ใช่ปัญหาสำหรับนักพัฒนาที่แท้จริง

ข้อเสียที่ใหญ่ที่สุดของการเก็บขยะใน C ++ คือว่ามันเป็นไปไม่ได้ที่จะได้รับ:

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

  ผลที่ตามมา: ตัวรวบรวมขยะ C ++ ใด ๆ จะรั่วไหลวัตถุที่ควรเก็บรวบรวม

• ใน C ++ คุณสามารถทำเลขคณิตตัวชี้เพื่อให้ได้พอยน์เตอร์ ดังนั้นหากคุณไม่พบตัวชี้ไปยังจุดเริ่มต้นของบล็อกนั่นไม่ได้หมายความว่าบล็อกนั้นไม่สามารถอ้างอิงได้

  ผลที่ตามมา: ตัวรวบรวมขยะ C ++ ใด ๆ จะต้องทำการปรับเปลี่ยนเหล่านี้โดยคำนึงถึงลำดับบิตใด ๆ ที่เกิดขึ้นที่จุดใดก็ได้ภายในบล็อก

  หมายเหตุ: ตัวรวบรวมขยะ C ++ ไม่สามารถจัดการกับรหัสด้วยลูกเล่นเช่นนี้:

  int* array = new int[7];
  array--;    //undefined behavior, but people may be tempted anyway...
  for(int i = 1; i <= 7; i++) array[i] = i;

  จริงสิ่งนี้เรียกใช้พฤติกรรมที่ไม่ได้กำหนด แต่โค้ดที่มีอยู่บางตัวนั้นฉลาดกว่าดีสำหรับมันและมันอาจทริกเกอร์การจัดสรรคืนเบื้องต้นโดยตัวรวบรวมขยะ