C++ Dynamischer Speicher

Zu verstehen, wie dynamischer Speicher in C++ funktioniert, ist wesentlich, um ein qualifizierter C++-Programmierer zu werden. Der Speicher in einem C++-Programm ist in zwei Teile unterteilt:

  • Stack:Alle innerhalb einer Funktion deklarierten Variablen belegen Stack-Speicher.
  • Heap:Dies ist Speicher, der nicht vom Programm verwendet wird und während der Programmausführung für dynamische Speicherzuweisung genutzt werden kann.

Oft kann man nicht im Voraus vorhersagen, wie viel Speicher benötigt wird, um bestimmte Informationen in einer definierten Variablen zu speichern; die erforderliche Speichergröße lässt sich erst zur Laufzeit bestimmen.

In C++ können Sie spezielle Operatoren verwenden, um zur Laufzeit Speicher im Heap für Variablen eines gegebenen Typs zuzuweisen, was die Adresse des zugewiesenen Speicherbereichs zurückgibt. Diese Operatoren sind dienewOperatoren.

Wenn Sie den dynamisch zugewiesenen Speicherplatz nicht mehr benötigen, können Sie dendelete-Operator verwenden, um den zuvor vom new-Operator zugewiesenen Speicher freizugeben.

new- und delete-Operatoren

Im Folgenden wird die allgemeine Syntax für die Verwendung des new-Operators zur dynamischen Speicherzuweisung für einen beliebigen Datentyp gezeigt:

new data-type;

Hierbei kanndata-typeein beliebiger integrierter Datentyp sein, einschließlich Arrays, oder ein beliebiger benutzerdefinierter Datentyp, einschließlich Klassen oder Strukturen. Betrachten wir zunächst die integrierten Datentypen. Zum Beispiel können wir einen Zeiger auf einen double-Typ definieren und dann Speicher anfordern, der zur Ausführungszeit zugewiesen wird. Wir können die folgende Anweisung verwenden:new-Operatoren, um dies zu erreichen:

double* pvalue = NULL; // Zeiger auf null initialisiert pvalue = new double; // Speicher für die Variable anfordern

Wenn der Freispeicher erschöpft ist, kann die Speicherzuweisung möglicherweise nicht erfolgreich sein. Daher wird empfohlen, zu prüfen, ob der new-Operator einen NULL-Zeiger zurückgibt, und geeignete Maßnahmen wie folgt zu ergreifen:

double* pvalue = NULL; if( !(pvalue = new double )) { cout << "Fehler: Nicht genügend Speicher." <<endl; exit(1); }

malloc()Die Funktion malloc() erschien in der Sprache C und existiert noch in C++, aber es wird empfohlen, malloc() nach Möglichkeit zu vermeiden. Im Vergleich zu malloc() besteht der Hauptvorteil von new darin, dass new nicht nur Speicher reserviert, sondern auch Objekte erzeugt.

Jederzeit, wenn Sie das Gefühl haben, dass eine Variable mit dynamisch zugewiesenem Speicher nicht mehr benötigt wird, können Sie den delete-Operator verwenden, um den von ihr belegten Speicher freizugeben, wie unten gezeigt:

delete pvalue;        // 释放 pvalue 所指向的内存

Das folgende Beispiel verwendet das obige Konzept und demonstriert, wie die Operatoren new und delete verwendet werden:

Beispiel

#include <iostream> using namespace std; int main () { double* pvalue = NULL; // Zeiger auf null initialisiert pvalue = new double; // Speicher für die Variable anfordern *pvalue = 29494.99; // Wert an der zugewiesenen Adresse speichern cout << "Wert von pvalue : " << *pvalue << endl; delete pvalue; // Speicher freigeben return 0; }

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

Value of pvalue : 29495

Dynamische Speicherzuweisung für Arrays

Angenommen, wir möchten Speicher für ein Zeichenarray (eine Zeichenkette mit 20 Zeichen) zuweisen. Wir können die Syntax aus dem obigen Beispiel verwenden, um Speicher für das Array dynamisch zuzuweisen, wie unten gezeigt:

char* pvalue  = NULL;   // 初始化为 null 的指针
pvalue  = new char[20]; // 为变量请求内存

Um das gerade erstellte Array zu löschen, lautet die Anweisung wie folgt:

delete [] pvalue;        // 删除 pvalue 所指向的数组

Das Folgende ist die allgemeine Syntax des new-Operators, der Speicher für mehrdimensionale Arrays zuweisen kann, wie unten gezeigt:

Eindimensionales Array

// dynamische Zuweisung, Array-Länge ist m int *array=new int [m]; // Speicher freigeben delete [] array;

Zweidimensionales Array

int **array; // Angenommen, die erste Dimension des Arrays hat die Länge m und die zweite Dimension die Länge n // Speicher dynamisch zuweisen array = new int *[m]; for( int i=0; i<m; i++ ) { array[i] = new int [n]; } // freigeben for( int i=0; i<m; i++ ) { delete [] array[i]; } delete [] array;

2D-Array-Instanztest:

Beispiel

#include <iostream> using namespace std; int main() { int **p; int i,j; //p[4][8] //Beginne mit der Allokation zweidimensionaler Daten mit 4 Zeilen und 8 Spalten p = new int *[4]; for(i=0;i<4;i++){ p[i]=new int [8]; } for(i=0; i<4; i++){ for(j=0; j<8; j++){ p[i][j] = j*i; } } //Daten ausgeben for(i=0; i<4; i++){ for(j=0; j<8; j++) { if(j==0) cout<<endl; cout<<p[i][j]<<"\t"; } } //Beginne mit der Freigabe des allokierten Heaps for(i=0; i<4; i++){ delete [] p[i]; } delete [] p; return 0; }

Dreidimensionales Array

int ***array; // Angenommen, die erste Dimension des Arrays ist m, die zweite ist n und die dritte ist h // Speicherplatz dynamisch reservieren array = new int **[m]; for( int i=0; i<m; i++ ) { array[i] = new int *[n]; for( int j=0; j<n; j++ ) { array[i][j] = new int [h]; } } // freigeben for( int i=0; i<m; i++ ) { for( int j=0; j<n; j++ ) { delete[] array[i][j]; } delete[] array[i]; } delete[] array;

3D-Array-Testinstanz:

Beispiel

#include <iostream> using namespace std; int main() { int i,j,k; // p[2][3][4] int ***p; p = new int **[2]; for(i=0; i<2; i++) { p[i]=new int *[3]; for(j=0; j<3; j++) p[i][j]=new int[4]; } // dreidimensionale Daten p[i][j][k] ausgeben for(i=0; i<2; i++) { for(j=0; j<3; j++) { for(k=0;k<4;k++) { p[i][j][k]=i+j+k; cout<<p[i][j][k]<<" "; } cout<<endl; } cout<<endl; } // Speicher freigeben for(i=0; i<2; i++) { for(j=0; j<3; j++) { delete [] p[i][j]; } } for(i=0; i<2; i++) { delete [] p[i]; } delete [] p; return 0; }

Dynamische Speicherzuweisung für Objekte

Objekte unterscheiden sich nicht von einfachen Datentypen. Sehen Sie sich beispielsweise den folgenden Code an; wir werden ein Array von Objekten verwenden, um dieses Konzept zu verdeutlichen:

Beispiel

#include <iostream> using namespace std; class Box { public: Box() { cout << "Konstruktor wird aufgerufen!" <<endl; } ~Box() { cout << "Destruktor wird aufgerufen!" <<endl; } }; int main( ) { Box* myBoxArray = new Box[4]; delete [] myBoxArray; // Array löschen return 0; }

Wenn Sie Speicher für ein Array zuweisen möchten, das vier Box-Objekte enthält, wird der Konstruktor 4 Mal aufgerufen; ebenso wird, wenn diese Objekte gelöscht werden, der Destruktor ebenfalls genauso oft aufgerufen (4 Mal).

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

Calling constructor!
Calling constructor!
Calling constructor!
Calling constructor!
Calling destructor!
Calling destructor!
Calling destructor!
Calling destructor!
Weitere Erweiterungen