เหตุใดไวยากรณ์ Delete[] จึงมีอยู่ใน C ++

ออบเจ็กต์ในภาษา C++ มักจะมีตัวทำลายที่ต้องทำงานเมื่อสิ้นสุดอายุการใช้งาน delete[] ทำให้แน่ใจว่ามีการเรียกตัวทำลายของแต่ละองค์ประกอบของอาร์เรย์ แต่การทำเช่นนี้ มีค่าใช้จ่ายที่ไม่ได้ระบุ ในขณะที่ delete ไม่. อันหนึ่งสำหรับอาร์เรย์ซึ่งจ่ายค่าใช้จ่ายและอีกอันสำหรับออบเจ็กต์เดี่ยวที่ไม่จ่าย

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

delete สิ่งที่คุณ new เสมอ และ delete[] สิ่งที่คุณ new[] เสมอ แต่ในภาษา C++ สมัยใหม่ โดยทั่วไปแล้ว new และ new[] จะไม่ถูกใช้อีกต่อไป ใช้ std::make_unique, std::make_shared, std::vector หรือทางเลือกอื่นๆ ที่ชัดเจนและปลอดภัยยิ่งขึ้น

โดยพื้นฐานแล้ว malloc และ free จัดสรรหน่วยความจำ และ new และ delete สร้างและทำลายอ็อบเจ็กต์ ดังนั้นคุณต้องรู้ว่าวัตถุคืออะไร

หากต้องการอธิบายรายละเอียดเกี่ยวกับคำตอบของ François Andrieux ที่ไม่ระบุรายละเอียด คุณสามารถดูคำตอบของฉันสำหรับคำถามนี้ ซึ่งฉันได้ตรวจสอบสิ่งที่ การใช้งานเฉพาะ (Visual C++ 2013, 32 บิต) การใช้งานอื่นๆ อาจทำหรือไม่ทำสิ่งที่คล้ายกัน

ในกรณีที่ new[] ถูกใช้กับอาร์เรย์ของอ็อบเจ็กต์ที่มีตัวทำลายที่ไม่ซับซ้อน สิ่งที่มันทำคือการจัดสรรเพิ่มอีก 4 ไบต์ และการส่งคืนตัวชี้ถูกเลื่อนไปข้างหน้า 4 ไบต์ ดังนั้นเมื่อ delete[] ต้องการทราบว่ามีอ็อบเจ็กต์อยู่กี่อ็อบเจ็กต์ มัน รับตัวชี้ เลื่อนไป 4 ไบต์ก่อนหน้า และรับตัวเลขไปยังที่อยู่นั้นและถือว่ามันเป็นจำนวนอ็อบเจ็กต์ที่เก็บไว้ที่นั่น จากนั้นจะเรียก destructor ในแต่ละวัตถุ (ขนาดของวัตถุนั้นทราบจากประเภทของตัวชี้ที่ส่งผ่าน) จากนั้น เพื่อที่จะเปิดเผยที่อยู่ที่แน่นอน มันจะส่งที่อยู่ที่มีขนาด 4 ไบต์ก่อนที่อยู่ที่ส่งไป

ในการใช้งานนี้ การส่งผ่านอาร์เรย์ที่จัดสรรด้วย new[] ไปยัง delete ปกติจะส่งผลให้มีการเรียกตัวทำลายล้างตัวเดียวขององค์ประกอบแรก ตามด้วยการส่งที่อยู่ผิดไปยังฟังก์ชันการจัดสรรคืน ซึ่งจะทำให้ฮีปเสียหาย อย่าทำ!

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

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

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

หูดในภาษา C++ นี้เกิดขึ้นเนื่องจากมรดกจาก C และยังคงเป็นส่วนหนึ่งของภาษา - แม้ว่าตอนนี้เราจะมี std::array สำหรับอาร์เรย์ที่มีความยาวคงที่และ (มีเสมอ) std::vector สำหรับอาร์เรย์ที่มีความยาวผันแปรได้ - ส่วนใหญ่เพื่อวัตถุประสงค์ของ ความเข้ากันได้: ความสามารถในการเรียกจาก C ++ ไปยัง API ของระบบปฏิบัติการและไปยังไลบรารีที่เขียนในภาษาอื่นโดยใช้การทำงานร่วมกันของภาษา C

และ ... เนื่องจากมีหนังสือ เว็บไซต์ และห้องเรียนมากมายที่สอนอาร์เรย์ เร็วมาก ในการสอน C++ เนื่องจาก ก) สามารถเขียนตัวอย่างที่เป็นประโยชน์/น่าสนใจตั้งแต่เนิ่นๆ ซึ่งในความเป็นจริงแล้ว เรียก OS API และแน่นอนว่าเป็นเพราะพลังอันน่าทึ่งของ b) นั่นคือวิธีที่เราทำมาโดยตลอด

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

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

ดังนั้นขนาดบล็อกที่จัดเก็บไว้ในตัวจัดการหน่วยความจำ C จึงไม่สามารถนำมาใช้ประโยชน์เพื่อเปิดใช้งานฟังก์ชันระดับที่สูงกว่าได้ หากฟังก์ชันการทำงานระดับสูงกว่าต้องการข้อมูลเกี่ยวกับขนาดของการจัดสรร ฟังก์ชันนั้นจะต้องจัดเก็บไว้เอง (และ C++ delete[] ต้องการสิ่งนี้สำหรับประเภทที่มี destructors เพื่อรันสำหรับทุกองค์ประกอบ)

C++ ยังมีทัศนคติของคุณที่จะจ่ายเฉพาะสิ่งที่คุณใช้ การจัดเก็บฟิลด์ที่มีความยาวพิเศษสำหรับการจัดสรรทุกครั้ง (แยกจากการทำบัญชีของผู้จัดสรรต้นแบบ) จะไม่เหมาะกับทัศนคตินี้

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

เรื่องปกคือ delete จำเป็นต้อง เนื่องจากความสัมพันธ์ของ C++ กับ C

ตัวดำเนินการ new สามารถสร้างออบเจ็กต์ที่จัดสรรแบบไดนามิกของออบเจ็กต์เกือบทุกชนิด

แต่เนื่องจากมรดกทางภาษา C ตัวชี้ไปยังประเภทอ็อบเจ็กต์จึงไม่ชัดเจนระหว่างสองนามธรรม:

• เป็นที่ตั้งของวัตถุชิ้นเดียวและ
• เป็นฐานของอาร์เรย์แบบไดนามิก

สถานการณ์ delete กับ delete[] ตามมาหลังจากนั้น

อย่างไรก็ตาม นั่นไม่เป็นความจริง เนื่องจากแม้ว่าข้อสังเกตข้างต้นจะเป็นจริง แต่ก็สามารถใช้โอเปอเรเตอร์ delete ตัวเดียวได้ มันไม่ได้เป็นไปตามตรรกะว่าจำเป็นต้องมีตัวดำเนินการสองตัว

นี่คือหลักฐานที่ไม่เป็นทางการ การร้องขอตัวดำเนินการ new T (กรณีวัตถุเดี่ยว) อาจทำงานโดยปริยายราวกับว่าเป็น new T[1] กล่าวคือ ทุก ๆ new สามารถจัดสรรอาร์เรย์ได้เสมอ เมื่อไม่มีการกล่าวถึงไวยากรณ์ของอาร์เรย์ อาจบอกเป็นนัยได้ว่าอาร์เรย์ [1] จะได้รับการจัดสรร จากนั้น ก็จะต้องมี delete ตัวเดียวซึ่งมีพฤติกรรมเหมือน delete[] ของวันนี้

เหตุใดจึงไม่ปฏิบัติตามการออกแบบนั้น

ฉันคิดว่ามันเป็นเรื่องปกติ: มันเป็นแพะที่ถูกบูชายัญต่อเทพเจ้าแห่งประสิทธิภาพ เมื่อคุณจัดสรรอาร์เรย์ด้วย new [] พื้นที่จัดเก็บเพิ่มเติมจะถูกจัดสรรสำหรับข้อมูลเมตาเพื่อติดตามจำนวนองค์ประกอบ เพื่อให้ delete [] สามารถทราบจำนวนองค์ประกอบที่ต้องทำซ้ำเพื่อทำลาย เมื่อคุณจัดสรรออบเจ็กต์เดี่ยวด้วย new ไม่จำเป็นต้องมีข้อมูลเมตาดังกล่าว สามารถสร้างออบเจ็กต์ได้โดยตรงในหน่วยความจำซึ่งมาจากตัวจัดสรรพื้นฐานโดยไม่ต้องมีส่วนหัวเพิ่มเติม

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

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

นี่คือตัวอย่าง:

#include <iostream>
#include <stdlib.h>
#include <string>

using std::cerr;
using std::cout;
using std::endl;

class silly_string : private std::string {
  public:
    silly_string(const char* const s) :
      std::string(s) {}
    ~silly_string() {
      cout.flush();
      cerr << "Deleting \"" << *this << "\"."
           << endl;
      // The destructor of the base class is now implicitly invoked.
    }

  friend std::ostream& operator<< ( std::ostream&, const silly_string& );
};

std::ostream& operator<< ( std::ostream& out, const silly_string& s )
{
  return out << static_cast<const std::string>(s);
}

int main()
{
  constexpr size_t nwords = 2;
  silly_string *const words = new silly_string[nwords]{
    "hello,",
    "world!" };

  cout << words[0] << ' '
       << words[1] << '\n';

  delete[] words;

  return EXIT_SUCCESS;
}

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

คอมไพเลอร์บางตัว เช่น clang++ นั้นฉลาดพอที่จะเตือนคุณหากคุณละเว้น [] ใน delete[] words; แต่ถ้าคุณบังคับให้คอมไพล์โค้ด buggy คุณจะได้รับความเสียหายแบบฮีป

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

สามารถใช้งานได้โดยใช้ตัวดำเนินการ Delete หรือตัวดำเนินการ Delete [ ] ตัวดำเนินการใหม่จะใช้สำหรับการจัดสรรหน่วยความจำแบบไดนามิกซึ่งวางตัวแปรไว้ในหน่วยความจำฮีป ซึ่งหมายความว่าตัวดำเนินการลบจะจัดสรรหน่วยความจำจากฮีป ตัวชี้ไปยังวัตถุไม่ถูกทำลาย ค่าหรือบล็อกหน่วยความจำที่ตัวชี้ชี้จะถูกทำลาย ตัวดำเนินการลบมีประเภทการส่งคืนเป็นโมฆะที่ไม่ส่งคืนค่า