Lorsque des vecteurs sont alloués, utilisent-ils de la mémoire sur le tas ou la pile?

Toutes les affirmations suivantes sont-elles vraies?

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. 

Comment la mémoire est-elle allouée en interne Typedans un vectorou tout autre conteneur STL?

vector<Type> vect;

allouera les vector, c'est-à-dire les informations d'en-tête, sur la pile, mais les éléments sur le magasin libre ("tas").

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

alloue tout sur la boutique gratuite.

vector<Type*> vect;

allouera le vectorsur la pile et un tas de pointeurs sur le magasin gratuit, mais où ces points sont déterminés par la façon dont vous les utilisez (vous pouvez pointer l'élément 0 vers le magasin libre et l'élément 1 vers la pile, par exemple).

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

Non, vectsera sur la pile, mais le tableau qu'il utilise en interne pour stocker les éléments sera sur le tas. Les éléments résideront dans ce tableau.

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

Non, comme ci-dessus, sauf que la vectorclasse sera également sur le tas.

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

vectsera sur la pile, ses éléments (pointeurs vers Type) seront sur le tas, et vous ne pouvez pas dire où seront les Types vers lesquels pointent les pointeurs. Peut être sur la pile, pourrait être sur le tas, pourrait être dans les données globales, pourrait être nulle part (par exemple. NULLPointeurs).

En fait, l'implémentation pourrait en fait stocker entièrement certains vecteurs (généralement de petite taille) sur la pile. Non pas que je connaisse une telle implémentation, mais c'est possible.

En supposant une implémentation qui a en fait une pile et un tas (le C ++ standard ne fait aucune obligation d'avoir de telles choses), la seule vraie déclaration est la dernière.

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

C'est vrai, sauf pour la dernière partie ( Typene sera pas sur la pile). Imaginer:

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

Également:

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

Vrai sauf la dernière partie, avec un exemple de compteur similaire:

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

Pour:

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

c'est vrai, mais notez ici que les Type*pointeurs seront sur le tas, mais les Typeinstances vers lesquelles ils pointent n'ont pas besoin d'être:

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

Seule cette affirmation est vraie:

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

Type* les pointeurs sont alloués sur le tas, car la quantité de pointeurs peut changer dynamiquement.

vect dans ce cas, il est alloué sur la pile, car vous l'avez défini comme une variable de pile locale.

vector a un interne allocatorqui est chargé d'allouer / désallouer des mémoires à partir heapde vector element. Quelle que soit la manière dont vous créez un vecteur, il elementest toujours alloué sur le heap. Quant aux métadonnées du vecteur, cela dépend de la façon dont vous le créez.