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

¿Son ciertas todas las siguientes afirmaciones?

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. 

¿Cómo se asigna internamente la memoria Typeen un vectorcontenedor STL o en otro?

vector<Type> vect;

asignará vector, es decir, la información del encabezado, en la pila, pero los elementos en la tienda gratuita ("montón").

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

asigna todo en la tienda gratuita.

vector<Type*> vect;

asignará el vectoren la pila y un montón de punteros en la tienda gratuita, pero donde este punto está determinado por cómo los usa (podría señalar el elemento 0 a la tienda libre y el elemento 1 a la pila, por ejemplo).

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

No, vectestará en la pila, pero la matriz que usa internamente para almacenar los elementos estará en el montón. Los artículos residirán en esa matriz.

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

No. Igual que el anterior, excepto que la vectorclase también estará en el montón.

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

vectestará en la pila, sus elementos (punteros a Type) estarán en el montón, y no se puede saber dónde estarán los Types a los que apuntan los punteros. Podría estar en la pila, podría estar en el montón, podría estar en los datos globales, podría estar en ninguna parte (es decir, NULLpunteros).

Por cierto, la implementación podría almacenar algunos vectores (típicamente de pequeño tamaño) en la pila por completo. No es que yo sepa de tal implementación, pero puede.

Suponiendo una implementación que realmente tiene una pila y un montón (C ++ estándar no requiere tener tales cosas), la única declaración verdadera es la última.

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

Esto es cierto, excepto por la última parte ( Typeno estará en la pila). Imagina:

  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);
  }

Igualmente:

 vector<Type> *vect = new vector<Type>; //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<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);
  }

Por:

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

Esto es cierto, pero tenga en cuenta aquí que los Type*punteros estarán en el montón, pero las Typeinstancias que señalan no necesitan ser:

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

Solo esta afirmación es verdadera:

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

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

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

el vector tiene un interno allocatorque se encarga de asignar / desasignar memorias heappara vector element. Entonces, no importa cómo cree un vector, elementsiempre se asigna en el heap. En cuanto a los metadatos del vector, depende de la forma en que lo cree.