Ketika vektor dialokasikan, apakah mereka menggunakan memori pada heap atau stack?

Apakah semua pernyataan berikut ini benar?

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. 

Bagaimana memori dialokasikan secara internal Typedalam vectorwadah STL atau lainnya?

vector<Type> vect;

akan mengalokasikan vector, yaitu info header, di stack, tetapi elemen-elemen di toko gratis ("heap").

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

mengalokasikan semuanya di toko gratis.

vector<Type*> vect;

akan mengalokasikan vectorpada stack dan banyak pointer di toko gratis, tetapi di mana titik ini ditentukan oleh bagaimana Anda menggunakannya (Anda bisa mengarahkan elemen 0 ke toko gratis dan elemen 1 ke stack, katakanlah).

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

Tidak, vectakan ada di stack, tetapi array yang digunakan secara internal untuk menyimpan item akan ada di heap. Item akan berada di array itu.

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

Tidak. Sama seperti di atas, kecuali vectorkelas akan berada di heap juga.

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

vectakan berada di tumpukan, itemnya (pointer ke Type) akan berada di heap, dan Anda tidak bisa tahu di mana akan menjadi Typetitik pointer ke. Bisa di stack, bisa di heap, bisa di data global, bisa di mana saja (mis.NULL Pointer).

BTW implementasi sebenarnya bisa menyimpan beberapa vektor (biasanya berukuran kecil) pada stack sepenuhnya. Bukan berarti saya tahu implementasi seperti itu, tetapi bisa.

Dengan asumsi implementasi yang sebenarnya memiliki tumpukan dan tumpukan (standar C ++ tidak membuat persyaratan untuk memiliki hal-hal seperti itu) satu-satunya pernyataan yang benar adalah yang terakhir.

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

Ini benar, kecuali untuk bagian terakhir ( Typetidak akan ada di tumpukan). Membayangkan:

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

Juga:

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

Benar kecuali bagian terakhir, dengan contoh penghitung serupa:

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

Untuk:

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

ini benar, tetapi perhatikan di sini bahwa Type*pointer akan berada di tumpukan, tetapi Typecontoh yang mereka tunjukkan tidak perlu:

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

Hanya pernyataan ini yang benar:

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

Type* pointer dialokasikan pada heap, karena jumlah pointer dapat berubah secara dinamis.

vect dalam hal ini dialokasikan pada stack, karena Anda mendefinisikannya sebagai variabel stack lokal.

vektor memiliki internal allocatoryang bertugas mengalokasikan / membatalkan alokasi memori dari heapuntuk vector element. Jadi, tidak masalah bagaimana Anda membuat vektor, elementselalu dialokasikan pada heap. Adapun metadata vektor, itu tergantung pada cara Anda membuatnya.