เมื่อมีการจัดสรรเวกเตอร์พวกเขาจะใช้หน่วยความจำบนกองหรือกอง?

ข้อความต่อไปนี้ทั้งหมดเป็นจริงหรือไม่?

vector<Type> vect; //allocates vect on stack and each of the Type (using std::allocator) also will be on the stack

vector<Type> *vect = new vector<Type>; //allocates vect on heap and each of the Type will be allocated on stack

vector<Type*> vect; //vect will be on stack and Type* will be on heap. 

เป็นวิธีการจัดสรรหน่วยความจำภายในสำหรับTypeในvectorหรือภาชนะ STL อื่น ๆ ?

vector<Type> vect;

จะจัดสรรvectorเช่นข้อมูลส่วนหัวในสแต็ก แต่องค์ประกอบในร้านค้าฟรี ("ฮีป")

vector<Type> *vect = new vector<Type>;

จัดสรรทุกอย่างในร้านค้าฟรี

vector<Type*> vect;

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

vector<Type> vect; //allocates vect on stack and each of the Type (using std::allocator) also will be on the stack

ไม่vectจะอยู่ในสแต็ก แต่อาร์เรย์ที่ใช้ภายในเพื่อเก็บรายการจะอยู่ในฮีป รายการจะอยู่ในอาร์เรย์นั้น

vector<Type> *vect = new vector<Type>; //allocates vect on heap and each of the Type will be allocated on stack

ไม่เหมือนข้างบนยกเว้นvectorชั้นเรียนจะอยู่บนกองเช่นกัน

vector<Type*> vect; //vect will be on stack and Type* will be on heap. 

vectจะอยู่ในสแต็กรายการของมัน (ตัวชี้ไปยังType) จะอยู่บนฮีปและคุณไม่สามารถบอกได้ว่าTypeตัวชี้จะชี้ไปที่ใด อาจอยู่ใน stack อาจเป็น heap อาจอยู่ในข้อมูลส่วนกลางอาจไม่มีที่ไหนเลย (เช่น. NULLpointers)

BTW การใช้งานจริงอาจเก็บเวกเตอร์บางตัว (โดยทั่วไปจะมีขนาดเล็ก) บนสแต็กทั้งหมด ไม่ใช่ว่าฉันรู้เรื่องการใช้งานเช่นนั้น แต่ก็สามารถทำได้

สมมติว่ามีการนำไปใช้งานซึ่งจริง ๆ แล้วมีกองและกอง (c ++ มาตรฐานทำให้ไม่มีความต้องการที่จะมีสิ่งต่าง ๆ ) ข้อความจริงเพียงอย่างเดียวคือคนสุดท้าย

vector<Type> vect;
//allocates vect on stack and each of the Type (using std::allocator) also will be on the stack

สิ่งนี้เป็นจริงยกเว้นส่วนสุดท้าย ( Typeจะไม่อยู่ในสแต็ก) Imagine:

  void foo(vector<Type>& vec) {
     // Can't be on stack - how would the stack "expand"
     // to make the extra space required between main and foo?
     vec.push_back(Type());
  }

  int main() {
    vector<Type> bar;
    foo(bar);
  }

ในทำนองเดียวกัน:

 vector<Type> *vect = new vector<Type>; //allocates vect on heap and each of the Type will be allocated on stack

True ยกเว้นส่วนสุดท้ายพร้อมด้วยตัวนับที่คล้ายกัน:

  void foo(vector<Type> *vec) {
     // Can't be on stack - how would the stack "expand"
     // to make the extra space required between main and foo?
     vec->push_back(Type());
  }

  int main() {
    vector<Type> *bar = new vector<Type>;
    foo(bar);
  }

สำหรับ:

vector<Type*> vect; //vect will be on stack and Type* will be on heap. 

นี่เป็นความจริง แต่โปรดสังเกตที่นี่ว่าพType*อยน์เตอร์จะอยู่บนฮีป แต่Typeอินสแตนซ์ที่ชี้ไปไม่จำเป็นต้องเป็น:

  int main() {
    vector<Type*> bar;
    Type foo;
    bar.push_back(&foo);
  }

เฉพาะข้อความนี้เท่านั้นที่เป็นจริง:

vector <Type*> vect; //vect will be on stack and Type* will be on heap.

Type* พอยน์เตอร์ได้รับการจัดสรรบนฮีปเนื่องจากจำนวนพอยน์เตอร์สามารถเปลี่ยนแปลงได้แบบไดนามิก

vect ในกรณีนี้ได้รับการจัดสรรในสแต็กเพราะคุณกำหนดเป็นตัวแปรสแต็คท้องถิ่น

เวกเตอร์มีภายในallocatorซึ่งเป็นค่าใช้จ่ายในการจัดสรร / deallocating จากความทรงจำสำหรับheap vector elementดังนั้นไม่ว่าคุณจะสร้างเวกเตอร์ของมันจะถูกจัดสรรเสมอในelement heapสำหรับเมตาดาต้าของเวกเตอร์นั้นขึ้นอยู่กับวิธีที่คุณสร้าง