web-dev-qa-db-fra.com

Quand les 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 pour Type dans un conteneur vector ou tout autre conteneur STL?

c++stlvectorstackheap
138
Phelodas
vector<Type> vect;

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

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

alloue tout sur le magasin gratuit.

vector<Type*> vect;

va allouer le vector sur la pile et un tas de pointeurs sur le magasin gratuit, mais lorsque ces points sont déterminés par la façon dont vous les utilisez (vous pouvez pointer l'élément 0 sur le magasin gratuit et l'élément 1 sur la pile, dire).

196
Fred Foo

En supposant une implémentation qui a réellement une pile et un tas (le C++ standard n'exige pas de telles choses), la seule déclaration vraie 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 (Type ne 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 le Type* Les pointeurs se trouveront sur le tas, mais les instances de Type qu’ils indiquent ne sont pas nécessairement:

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

Non, vect sera sur la pile, mais le tableau utilisé 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

Comme ci-dessus, sauf que la classe vector sera également sur le tas.

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

vect sera sur la pile, ses éléments (pointeurs vers Type) seront sur le tas, et vous ne pouvez pas dire où sera le Types les pointeurs pointés . Pourrait être sur pile, pourrait être sur le tas, pourrait être dans les données globales, pourrait être nulle part (ie. NULL pointeurs).

En effet, l’implémentation pourrait en fait stocker certains vecteurs (généralement de petite taille) sur la pile. Pas que je sache une telle implémentation, mais c'est possible.

21
jpalecek

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 leur nombre peut changer de manière dynamique.

vect dans ce cas, est alloué sur pile, car vous l'avez défini en tant que variable de pile locale.

3
Alexei Khlebnikov