std :: vector (ab) ใช้ที่เก็บข้อมูลอัตโนมัติ

พิจารณาตัวอย่างต่อไปนี้:

#include <array>
int main() {
  using huge_type = std::array<char, 20*1024*1024>;
  huge_type t;
}

เห็นได้ชัดว่ามันจะผิดพลาดในแพลตฟอร์มส่วนใหญ่เนื่องจากขนาดสแต็คเริ่มต้นมักจะน้อยกว่า 20MB

พิจารณารหัสต่อไปนี้:

#include <array>
#include <vector>

int main() {
  using huge_type = std::array<char, 20*1024*1024>;
  std::vector<huge_type> v(1);
}

น่าแปลกที่มันเกิดปัญหาเช่นกัน! การย้อนกลับ (ด้วยหนึ่งในเวอร์ชันล่าสุดของ libstdc ++) นำไปสู่include/bits/stl_uninitialized.hไฟล์ซึ่งเราสามารถเห็นบรรทัดต่อไปนี้:

typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
std::fill(__first, __last, _ValueType());

ตัวvectorสร้างปรับขนาดต้องเริ่มต้นองค์ประกอบและนี่คือวิธีการใช้งาน เห็นได้ชัดว่า_ValueType()ชั่วคราวเกิดปัญหาสแต็ก

คำถามคือการใช้งานที่สอดคล้องหรือไม่ ถ้าใช่จริง ๆ แล้วหมายความว่าการใช้เวกเตอร์ขนาดใหญ่นั้นค่อนข้าง จำกัด ใช่ไหม?

ไม่มีการ จำกัด จำนวนหน่วยเก็บข้อมูลอัตโนมัติที่ std API ใช้

พวกเขาทุกคนต้องการพื้นที่สแต็ก 12 เทราไบต์

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

huge_type t;

เห็นได้ชัดว่ามันจะผิดพลาดในแพลตฟอร์มส่วนใหญ่ ...

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

คำถามคือการใช้งานที่สอดคล้องหรือไม่

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

จริงๆแล้วมันหมายความว่าการใช้เวกเตอร์ขนาดใหญ่นั้นค่อนข้าง จำกัด ใช่ไหม?

ที่ดูเหมือนจะเป็นกรณีที่มี libstdc ++ ความผิดพลาดไม่ได้ทำซ้ำโดยใช้ libc ++ (โดยใช้เสียงดังกราว) ดังนั้นจึงดูเหมือนว่านี่ไม่ใช่ข้อ จำกัด ในภาษา แต่จะใช้เฉพาะในการนำไปใช้นั้นเท่านั้น

ฉันไม่ใช่ทนายความด้านภาษาหรือผู้เชี่ยวชาญมาตรฐาน C ++ แต่ cppreference.com พูดว่า:

explicit vector( size_type count, const Allocator& alloc = Allocator() );

สร้างคอนเทนเนอร์ที่มีอินสแตนซ์ที่นับจำนวนเริ่มต้นของ T ไม่มีการทำสำเนา

บางทีฉันอาจเข้าใจผิด "แทรกค่าเริ่มต้น" แต่ฉันคาดหวัง:

std::vector<huge_type> v(1);

จะเท่ากับ

std::vector<huge_type> v;
v.emplace_back();

รุ่นหลังไม่ควรสร้างสำเนาสแต็ก แต่สร้าง huge_type โดยตรงในหน่วยความจำไดนามิกของเวกเตอร์

ฉันไม่สามารถพูดอย่างเผด็จการได้ว่าสิ่งที่คุณเห็นนั้นไม่สอดคล้อง แต่ก็ไม่ใช่สิ่งที่ฉันคาดหวังจากการใช้งานที่มีคุณภาพ