Quando vetores são alocados, eles usam memory no heap ou na pilha?

Todas as afirmações a seguir são verdadeiras?

vector vect; //allocates vect on stack and each of the Type (using std::allocator) also will be on the stack vector *vect = new vector; //allocates vect on heap and each of the Type will be allocated on stack vector vect; //vect will be on stack and Type* will be on heap. 

Como a memory é alocada internamente para Type em um vector ou qualquer outro contêiner STL?

 vector vect; 

irá alocar o vector , ou seja, as informações do header, na pilha, mas os elementos na loja livre (“heap”).

 vector *vect = new vector; 

aloca tudo na loja gratuita.

 vector vect; 

irá alocar o vector na pilha e um monte de pointers na loja livre, mas onde esses pontos são determinados pela forma como você os usa (você pode apontar o elemento 0 para o armazenamento livre e o elemento 1 para a pilha, digamos).

Supondo uma implementação que realmente tenha uma pilha e um heap (o padrão C ++ não requer que essas coisas sejam feitas), a única afirmação verdadeira é a última.

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

Isso é verdade, exceto pela última parte (o Type não estará na pilha). Imagine:

  void foo(vector& 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 bar; foo(bar); } 

Da mesma forma:

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

Verdadeiro, exceto a última parte, com um exemplo contrário semelhante:

  void foo(vector *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 *bar = new vector; foo(bar); } 

Para:

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

isso é verdade, mas observe aqui que os pointers Type* estarão no heap, mas as instâncias de Type eles apontam não precisam ser:

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

Não, vect estará na pilha, mas o array que ele usa internamente para armazenar os itens estará no heap. Os itens residirão nessa matriz.

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

Não. O mesmo que acima, apenas a class de vector estará no heap.

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

vect estará na pilha, seus itens (pointers para Type ) estarão no heap, e você não pode dizer onde serão os Type s apontados pelos pointers. Poderia estar na pilha, poderia estar na pilha, poderia estar nos dados globais, poderia estar em nenhuma parte (ou seja, pointers NULL ).

BTW, a implementação poderia, de fato, armazenar alguns vetores (tipicamente de tamanho pequeno) na pilha por completo. Não que eu saiba de qualquer implementação, mas pode.

Apenas esta afirmação é verdadeira:

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

Type* pointers Type* são alocados no heap, porque a quantidade de pointers pode mudar dinamicamente.

vect neste caso é alocado na pilha, porque você definiu como uma variável de pilha local.