Cuando se asignan vectores, ¿usan memoria en el montón o la stack?

¿Son verdaderas todas las siguientes afirmaciones?

vector vect; //allocates vect on stack and each of the Type (using std::allocator) also will be on the stack vector *vect = new vector; //allocates vect on heap and each of the Type will be allocated on stack vector vect; //vect will be on stack and Type* will be on heap. 

¿Cómo se asigna internamente la memoria para Type en un vector o cualquier otro contenedor STL?

 vector vect; 

asignará el vector , es decir, la información del encabezado, en la stack, pero los elementos en la tienda libre (“montón”).

 vector *vect = new vector; 

asigna todo en la tienda gratuita.

 vector vect; 

asignará el vector en la stack y un montón de punteros en la tienda gratuita, pero donde estos puntos están determinados por cómo los usa (puede señalar el elemento 0 a la tienda gratuita y el elemento 1 a la stack, por ejemplo).

Asumiendo una implementación que en realidad tiene una stack y un montón (C ++ estándar no requiere tener tales cosas) la única statement verdadera es la última.

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

Esto es cierto, a excepción de la última parte ( Type no estará en la stack). Imagina:

  void foo(vector& 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 bar; foo(bar); } 

Igualmente:

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

Verdadero, excepto la última parte, con un ejemplo de contador similar:

  void foo(vector *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 *bar = new vector; foo(bar); } 

Por:

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

esto es cierto, pero tenga en cuenta que los punteros Type* estarán en el montón, pero las instancias Type que apuntan no necesitan ser:

  int main() { vector bar; Type foo; bar.push_back(&foo); } 
 vector vect; //allocates vect on stack and each of the Type (using std::allocator) also will be on the stack 

No, vect estará en la stack, pero la matriz que usa internamente para almacenar los elementos estará en el montón. Los elementos residirán en esa matriz.

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

No. Igual que arriba, solo la clase vector estará en el montón.

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

vect estará en la stack, sus elementos (punteros a Type ) estarán en el montón, y no se puede decir dónde estarán los Type s señalados por los punteros. Podría estar en la stack, podría estar en el montón, podría estar en los datos globales, podría estar en ninguna parte (es decir, punteros NULL ).

Por cierto, la implementación podría almacenar algunos vectores (generalmente de pequeño tamaño) en la stack por completo. No es que conozca tal implementación, pero puede hacerlo.

Solo esta statement es verdadera:

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

Type* punteros de Type* se asignan en el montón, porque la cantidad de punteros puede cambiar dinámicamente.

vect en este caso se asigna a la stack, porque la definiste como una variable de stack local.