Khi các vectơ được phân bổ, chúng có sử dụng bộ nhớ trên heap hoặc stack không?

Có phải tất cả các tuyên bố sau đây là đúng?

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. 

Bộ nhớ được phân bổ nội bộ Typetrong một vectorhoặc bất kỳ container STL nào khác?

vector<Type> vect;

sẽ phân bổ vector, tức là thông tin tiêu đề, trên ngăn xếp, nhưng các yếu tố trên cửa hàng miễn phí ("heap").

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

phân bổ mọi thứ trên cửa hàng miễn phí.

vector<Type*> vect;

sẽ phân bổ vectortrên ngăn xếp và một loạt các con trỏ trên cửa hàng miễn phí, nhưng ở đó những điểm này được xác định bằng cách bạn sử dụng chúng (bạn có thể trỏ phần tử 0 vào cửa hàng miễn phí và phần tử 1 vào ngăn xếp, giả sử).

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

Không, vectsẽ nằm trên stack, nhưng mảng nó sử dụng bên trong để lưu trữ các mục sẽ nằm trong heap. Các mục sẽ nằm trong mảng đó.

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

Không. Giống như trên, ngoại trừ vectorlớp cũng sẽ ở trên đống.

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

vectsẽ ở trên ngăn xếp, các mục của nó (con trỏ tới Type) sẽ nằm trên đống, và bạn không thể biết nơi nào sẽ là Typecon trỏ trỏ tới. Có thể là trên stack, có thể là trên heap, có thể là trong dữ liệu toàn cầu, có thể là hư không (ví dụ: NULLcon trỏ).

BTW thực hiện trên thực tế có thể lưu trữ một số vectơ (thường có kích thước nhỏ) trên ngăn xếp hoàn toàn. Không phải tôi biết về bất kỳ thực hiện như vậy, nhưng nó có thể.

Giả sử một triển khai thực sự có một ngăn xếp và một đống (C ++ tiêu chuẩn không yêu cầu phải có những thứ như vậy) thì tuyên bố đúng duy nhất là tuyên bố cuối cùng.

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

Điều này là đúng, ngoại trừ phần cuối cùng ( Typesẽ không nằm trong ngăn xếp). Hãy tưởng tượng:

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

Tương tự như vậy:

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

Đúng ngoại trừ phần cuối cùng, với một ví dụ truy cập tương tự:

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

Dành cho:

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

Điều này là đúng, nhưng lưu ý ở đây là các Type*con trỏ sẽ nằm trong heap, nhưng các Typetrường hợp chúng chỉ ra không cần phải là:

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

Chỉ tuyên bố này là đúng:

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

Type* con trỏ được phân bổ trên heap, bởi vì số lượng con trỏ có thể thay đổi linh hoạt.

vect trong trường hợp này được phân bổ trên ngăn xếp, bởi vì bạn đã xác định nó là biến ngăn xếp cục bộ.

vector có một nội bộ allocatorchịu trách nhiệm phân bổ / giải phóng các ký ức từ heapcho vector element. Vì vậy, bất kể bạn tạo một vectơ như thế nào, nó elementluôn được phân bổ trên heap. Đối với siêu dữ liệu của vectơ, nó phụ thuộc vào cách bạn tạo nó.