Quando os vetores são alocados, eles usam memória na pilha ou na pilha?

Todas as seguintes afirmações são verdadeiras?

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. 

Como a memória é alocada internamente para Typeum vectorou qualquer outro contêiner STL?

vector<Type> vect;

alocará a vector, ou seja, as informações do cabeçalho, na pilha, mas os elementos no armazenamento gratuito ("heap").

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

aloca tudo na loja gratuita.

vector<Type*> vect;

alocará o vectorna pilha e vários ponteiros no armazenamento gratuito, mas onde esses pontos são determinados pela maneira como você os usa (você pode apontar o elemento 0 para o armazenamento gratuito e o elemento 1 para a pilha, digamos).

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

Não, vectestará na pilha, mas a matriz que ela usa internamente para armazenar os itens estará na pilha. Os itens residirão nessa matriz.

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

Não. O mesmo que acima, exceto que a vectorclasse também estará na pilha.

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

vectestará na pilha, seus itens (ponteiros para Type) estarão na pilha e você não pode dizer onde serão Typeos pontos apontados pelos ponteiros. Pode estar na pilha, pode estar na pilha, pode estar nos dados globais, pode estar em lugar nenhum (isto é, NULLponteiros).

Aliás, a implementação pode de fato armazenar alguns vetores (geralmente de tamanho pequeno) na pilha completamente. Não que eu conheça alguma dessas implementações, mas pode.

Supondo que uma implementação que realmente tenha uma pilha e uma pilha (C ++ padrão não exija a exigência de tais coisas), a única declaração verdadeira é a última.

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

Isso é verdade, exceto a última parte ( Typenão estará na pilha). Imagine:

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

Da mesma forma:

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

True, exceto a última parte, com um exemplo de contador semelhante:

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

Para:

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

isso é verdade, mas observe aqui que os Type*ponteiros estarão na pilha, mas as Typeinstâncias para as quais eles apontam não precisam ser:

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

Somente esta afirmação é verdadeira:

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

Type* ponteiros são alocados na pilha, porque a quantidade de ponteiros pode mudar dinamicamente.

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

vector tem um interno allocatorque é responsável por alocar / desalocar memórias de heappara o vector element. Portanto, não importa como você crie um vetor, ele elementsempre será alocado no heap. Quanto aos metadados do vetor, isso depende da maneira como você os cria.