Verwenden Vektoren bei der Zuweisung Speicher auf dem Heap oder dem Stapel?

Sind alle folgenden Aussagen wahr?

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. 

Wie wird der Speicher intern Typein einem vectoroder einem anderen STL-Container zugewiesen ?

vector<Type> vect;

ordnet die vector, dh die Header-Informationen, dem Stapel zu, aber die Elemente im freien Speicher ("Heap").

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

ordnet alles im freien Laden zu.

vector<Type*> vect;

ordnet das vectorauf dem Stapel und eine Reihe von Zeigern auf dem freien Speicher zu, aber wo dieser Punkt bestimmt wird, hängt davon ab, wie Sie sie verwenden (Sie könnten beispielsweise Element 0 auf den freien Speicher und Element 1 auf den Stapel zeigen).

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

Nein, vectbefindet sich auf dem Stapel, aber das Array, das intern zum Speichern der Elemente verwendet wird, befindet sich auf dem Heap. Die Elemente befinden sich in diesem Array.

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

Nein. Wie oben, außer dass die vectorKlasse ebenfalls auf dem Haufen liegt.

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

vectbefindet sich auf dem Stapel, seine Elemente (Zeiger auf Type) befinden sich auf dem Heap, und Sie können nicht sagen, auf welche Types die Zeiger zeigen. Könnte auf dem Stapel sein, könnte auf dem Heap sein, könnte in den globalen Daten sein, könnte nirgendwo sein (dh NULLZeiger).

Übrigens könnte die Implementierung tatsächlich einige Vektoren (typischerweise von geringer Größe) vollständig auf dem Stapel speichern. Nicht dass ich von einer solchen Implementierung wüsste, aber es kann.

Unter der Annahme einer Implementierung, die tatsächlich einen Stapel und einen Heap enthält (Standard-C ++ erfordert solche Dinge nicht), ist die einzig wahre Aussage die letzte.

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

Dies gilt bis auf den letzten Teil ( Typewird nicht auf dem Stapel sein). Vorstellen:

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

Gleichfalls:

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

Richtig mit Ausnahme des letzten Teils mit einem ähnlichen Gegenbeispiel:

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

Zum:

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

Dies ist wahr, aber beachten Sie hier, dass sich die Type*Zeiger auf dem Heap befinden, aber die TypeInstanzen, auf die sie verweisen, müssen nicht sein:

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

Nur diese Aussage ist wahr:

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

Type* Zeiger werden auf dem Heap zugewiesen, da sich die Anzahl der Zeiger dynamisch ändern kann.

vect In diesem Fall wird der Stapel zugewiesen, da Sie ihn als lokale Stapelvariable definiert haben.

Der Vektor hat einen internen, allocatorder für die Zuweisung / Freigabe von Speichern von heapfür die zuständig ist vector element. Egal wie Sie einen Vektor erstellen, er elementwird immer auf dem Vektor zugewiesen heap. Die Metadaten des Vektors hängen davon ab, wie Sie ihn erstellen.