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.

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

Answer 1

vector<Type> vect;

将在堆栈上分配vector，即标题信息，但是在免费商店（“堆”）上分配元素。

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

在免费商店分配所有内容。

vector<Type*> vect;

将在堆栈上分配vector并在免费商店上分配一堆指针，但这些点由您使用它们的方式决定（您可以将元素0指向免费商店，将元素1指向堆栈，说）。

Answer 2

假设一个实际上有堆栈和堆的实现（标准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个实例不必是：

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

Answer 3

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

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

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

没有。与上面相同，只有vector类将在堆上。

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

vect将在堆栈上，它的项目（指向Type的指针）将在堆上，你无法分辨指针指向Type的位置至。可能在堆栈上，可能在堆上，可能在全局数据中，可能无处（即。NULL指针）。

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

Answer 4

只有这句话是真的：

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

Type*指针在堆上分配，因为指针的数量可以动态改变。

在这种情况下，

vect在堆栈上分配，因为您将其定义为本地堆栈变量。

Answer 5

vector有一个内部allocator，负责为heap从vector element分配内存。因此，无论您如何创建矢量，其element总是分配在heap上。至于向量的元数据，取决于您创建向量的方式。

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

5 个答案: