分配向量时，它们使用堆上的内存还是堆栈上的内存？

Question

以下所有陈述都正确吗？

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. 

在 vector 或任何其他 STL 容器中，如何在内部为 Type 分配内存？

Answer 1

vector<Type> vect;

将在堆栈上分配向量（即标头信息），但在空闲存储（“堆”）上分配元素。

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

分配空闲存储上的所有内容（除了位于堆栈上的 vect 指针）。

vector<Type*> vect;

将在堆栈上分配向量并在自由存储上分配一堆指针，但这些点的位置取决于您如何使用它们（您可以将元素 0 指向自由存储，将元素 1 指向堆栈，说）。

Answer 2

向量<类型>向量； // 在堆栈上分配 vect 并且每个类型（使用 std::allocator）也将在堆栈上

不，vect 将位于堆栈上，但它内部用于存储项目的数组将位于堆上。这些项目将驻留在该数组中。

向量<类型> *vect = 新向量<类型>; //在堆上分配vect，每个类型将在堆栈上分配

不会。与上面相同，只是 vector 类也将位于堆上。

向量<类型*>向量； //vect 将位于堆栈上，而 Type* 将位于堆上。 

vect 将位于堆栈上，其项（指向 Type 的指针）将位于堆上，并且您无法判断 Type 将位于何处code> 是指针所指向的。可能在堆栈上，可能在堆上，可能在全局数据中，也可能不在任何地方（即NULL指针）。

顺便说一句，该实现实际上可以将一些向量（通常尺寸较小）完全存储在堆栈上。我不知道有任何这样的实现，但它可以。

Answer 3

假设一个实现实际上有一个栈和一个堆（标准 C++ 不要求有这样的东西），唯一正确的语句是最后一个。

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

这是真的，除了最后一部分（Type 不会在堆栈上）。想象一下：

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

同样：

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

除了最后一部分之外，

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

为真，有一个类似的反例：对于：

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

这是真的，但请注意，Type* 指针将位于堆上，但 Type< /code> 它们指向的实例不必是：

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

Answer 4

矢量有一个内部分配器，负责从堆中为矢量元素分配/释放内存。因此，无论您如何创建向量，其元素始终分配在堆上。至于矢量的元数据，这取决于您创建它的方式。

Answer 5

只有这句话是正确的：

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

Type* 指针存储在堆上，因为指针的数量可以动态变化。

在这种情况下，vect 是在堆栈上分配的，因为您将其定义为本地堆栈变量。