una - vectores c++

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

Question

¿Son verdaderas 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 para Type en un vector o cualquier otro contenedor STL?

Answer 1

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

No, vect estará en la pila, pero la matriz que usa internamente para almacenar los elementos estará en el montón. Los elementos 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 arriba, solo la clase vector estará en el montón.

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

vect estará en la pila, 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 pila, 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 pila por completo. No es que conozca tal implementación, pero puede hacerlo.

Answer 2

Asumiendo una implementación que en realidad 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, a excepción de la última parte ( Type no 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 que los punteros Type* estarán en el montón, pero las instancias Type que apuntan no necesitan ser:

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

Answer 3

Solo esta declaración es verdadera:

vector <Type*> 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 pila, porque la definiste como una variable de pila local.

Answer 4

vector<Type> vect;

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

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

asigna todo en la tienda gratuita.

vector<Type*> vect;

asignará el vector en la pila 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 pila, por ejemplo).