Quando vengono allocati i vettori, usano la memoria nell'heap o nello stack?

Sono vere tutte le seguenti affermazioni?

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. 

Come viene allocata la memoria internamente Typein uno vectoro qualsiasi altro contenitore STL?

vector<Type> vect;

alloca vector, ovvero le informazioni di intestazione, nello stack, ma gli elementi nel negozio gratuito ("heap").

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

alloca tutto sul negozio gratuito.

vector<Type*> vect;

assegnerà lo vectorstack e un gruppo di puntatori nello store gratuito, ma dove questi punti sono determinati da come li usi (puoi dire l'elemento 0 allo store gratuito e l'elemento 1 allo stack, diciamo).

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

No, vectsarà nello stack, ma l'array che utilizza internamente per archiviare gli oggetti sarà nell'heap. Gli articoli risiederanno in quell'array.

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

No. Come sopra, tranne per il fatto che la vectorclasse sarà anche nell'heap.

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

vectsarà nello stack, i suoi elementi (puntatori a Type) saranno nell'heap e non puoi dire dove saranno i Types cui puntano i puntatori. Potrebbe essere nello stack, potrebbe essere nell'heap, potrebbe essere nei dati globali, potrebbe non essere da nessuna parte (es. NULLPuntatori).

A proposito l'implementazione potrebbe infatti memorizzare alcuni vettori (in genere di piccole dimensioni) nello stack interamente. Non che io conosca tale implementazione, ma può farlo.

Supponendo un'implementazione che in realtà ha uno stack e un heap (lo standard C ++ non richiede di avere tali cose) l'unica vera affermazione è l'ultima.

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

Questo è vero, tranne per l'ultima parte ( Typenon sarà nello stack). Immaginare:

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

Allo stesso modo:

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

Vero tranne l'ultima parte, con un contro esempio simile:

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

Per:

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

questo è vero, ma nota qui che i Type*puntatori saranno sull'heap, ma le Typeistanze che indicano non devono essere:

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

Solo questa affermazione è vera:

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

Type* i puntatori sono allocati sull'heap, poiché la quantità di puntatori può cambiare in modo dinamico.

vect in questo caso viene allocato nello stack, perché è stato definito come una variabile dello stack locale.

il vettore ha un interno allocatorche si occupa di allocare / deallocare memorie da heapper vector element. Quindi, indipendentemente da come si crea un vettore, elementviene sempre allocato su heap. Per quanto riguarda i metadati del vettore, dipende dal modo in cui lo crei.