Vektörler ayrıldığında, yığın veya yığın üzerinde bellek kullanıyorlar mı?

Aşağıdaki ifadelerin tümü doğru mu?

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. 

Nasıl bellek için dahili olarak tahsis edilir Typebir yer vectorya da başka bir STL konteyner?

vector<Type> vect;

vectorbaşlık bilgisini yani yığın bilgisini yığına tahsis eder , ancak serbest depodaki öğeleri ("öbek") tahsis eder .

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

her şeyi ücretsiz mağazaya tahsis eder.

vector<Type*> vect;

tahsis edecek vectoryığını ve ücretsiz mağaza işaretçiler oluşan bir demet, ancak bu nokta bunları kullanmak nasıl belirlenir nerede (eğer yığını ücretsiz mağazası ve eleman 1'e elemanı 0 eder misiniz derler).

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

Hayır, vectyığın üzerinde olacak, ancak öğeleri depolamak için dahili olarak kullandığı dizi öbek üzerinde olacak. Öğeler bu dizide yer alacaktır.

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

Hayır. Sınıfla aynı vectorşekilde, yığın da olacaktır.

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

vectyığını üzerinde olacak, öğeleri (işaretçileri Type) yığın üzerinde olacak Typeve işaretçilerin işaret ettiği noktaların nerede olacağını söyleyemezsiniz . Yığın üzerinde olabilir, yığın üzerinde olabilir, küresel verilerde olabilir, hiçbir yerde (yani NULLişaretçiler) olabilir.

BTW uygulaması aslında bazı vektörleri (tipik olarak küçük boyutlu) yığına tamamen depolayabilir. Böyle bir uygulamayı bildiğimden değil, ama yapabilir.

Aslında bir yığın ve bir yığın (standart C ++ böyle şeylere sahip olma zorunluluğu yoktur) bir uygulama varsayarsak, tek doğru ifade sonuncusu.

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

Bu son kısım hariç doğrudur ( Typeyığın üzerinde olmayacak). Hayal etmek:

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

Aynı şekilde:

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

Benzer bir sayaç örneği ile son bölüm hariç doğrudur:

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

İçin:

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

bu doğrudur, ancak burada Type*işaretçilerin yığın üzerinde olacağını, ancak Typeişaret etmeleri gereken örneklerin olmayacağını unutmayın:

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

Yalnızca bu ifade doğrudur:

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

Type* işaretçiler yığın üzerinde ayrılır, çünkü işaretçilerin miktarı dinamik olarak değişebilir.

vect bu durumda yerel bir yığın değişkeni olarak tanımladığınız için yığına ayrılır.

Vektör, bir iç var allocator/ ayırmalarına anılar ayırmayı kaldırma sorumlu olan heapiçin vector element. Yani nasıl bir vektör oluşturursanız olun element, her zaman heap. Vektörün meta verilerine gelince, onu oluşturma şeklinize bağlıdır.