Unter dynamischer Speicherzuweisung in C/C++ versteht man die manuelle Speicherzuweisung durch einen Programmierer. Dynamisch zugewiesener Speicher wird zugewiesen Haufen, und nicht statischen und lokalen Variablen wird Speicher zugewiesen Stapel (Beziehen auf Speicherlayout von C-Programmen für Details).

Was sind Anwendungen?

• Eine Verwendung von dynamisch zugewiesenem Speicher besteht darin, Speicher variabler Größe zuzuweisen, was mit vom Compiler zugewiesenem Speicher nicht möglich ist, außer Arrays variabler Länge .
• Der wichtigste Nutzen ist die Flexibilität, die Programmierern geboten wird. Es steht uns frei, Speicher zuzuweisen und freizugeben, wann immer wir ihn benötigen und wann immer wir ihn nicht mehr benötigen. In vielen Fällen hilft diese Flexibilität. Beispiele für solche Fälle sind Baum , usw.

Wie unterscheidet es sich vom Speicher, der normalen Variablen zugewiesen ist?

Für normale Variablen wie int a, char str[10] usw. wird Speicher automatisch zugewiesen und freigegeben. Bei dynamisch zugewiesenem Speicher wie int *p = new int[10] liegt es in der Verantwortung des Programmierers, Speicher freizugeben, wenn er nicht mehr benötigt wird. Wenn der Programmierer den Speicher nicht freigibt, führt dies zu einem Fehler Speicherleck (Der Speicher wird erst freigegeben, wenn das Programm beendet wird.)

Wie wird Speicher in C++ zugewiesen/freigegeben?
C verwendet die malloc() und calloc() Funktion zum dynamischen Zuweisen von Speicher zur Laufzeit und verwendet eine free()-Funktion zum Freigeben von dynamisch zugewiesenem Speicher. C++ unterstützt diese Funktionen und verfügt außerdem über zwei Operatoren neu Und löschen, die die Aufgabe der Speicherzuweisung und -freigabe besser und einfacher erfüllen.

neuer Betreiber

Der neue Operator bezeichnet eine Anforderung zur Speicherzuweisung im Free Store. Wenn ausreichend Speicher verfügbar ist, initialisiert ein neuer Operator den Speicher und gibt die Adresse des neu zugewiesenen und initialisierten Speichers an die Zeigervariable zurück.

Syntax zur Verwendung des neuen Operators

Beispiele für Java-Code

pointer-variable =   new   data-type;>

Hier ist die Zeigervariable der Zeiger vom Typ Datentyp. Der Datentyp kann jeder integrierte Datentyp, einschließlich Array, oder jeder benutzerdefinierte Datentyp, einschließlich Struktur und Klasse, sein.
Beispiel:

// Pointer initialized with NULL // Then request memory for the variable int *p = NULL;  p = new int;    OR  // Combine declaration of pointer  // and their assignment int *p = new int;>

// C++ program to demonstrate how to create dynamic variable // using new #include  #include  using namespace std; int main() {  // pointer to store the address returned by the new  int* ptr;  // allocating memory for integer  ptr = new int;  // assigning value using dereference operator  *ptr = 10;  // printing value and address  cout << 'Address: ' << ptr << endl;  cout << 'Value: ' << *ptr;  return 0; }>

Address: 0x162bc20 Value: 10>

Speicher initialisieren: Wir können den Speicher für integrierte Datentypen auch mit einem neuen Operator initialisieren. Für benutzerdefinierte Datentypen ist ein Konstruktor (mit dem Datentyp als Eingabe) zum Initialisieren des Werts erforderlich. Hier ist ein Beispiel für die Initialisierung beider Datentypen:

pointer-variable =   new   data-type(value);>

Beispiel:

// C++ program to illustrate how to initialize a dynamic // variable with allocation #include  #include  using namespace std; // Custom data type with constructor to take initial value struct cust {  int p;  cust(int q)  : p(q)  {  }  cust() = default; }; int main() {  // creating inbuit data types with initial value  int* p = new int(25);  float* q = new float(75.25);  // Works fine, doesn’t require constructor  cust* var1 = new cust;  // OR  // Works fine, doesn’t require constructor  var1 = new cust();  // Notice error if you comment this line  cust* var = new cust(25);  cout << *p << ' ' << *q << ' ' << var->P;  0 zurückgeben; }>

25 75.25 25>

Weisen Sie einen Speicherblock zu: Ein neuer Operator wird auch verwendet, um einen Speicherblock (ein Array) des Typs zuzuweisen Datentyp .

pointer-variable =   new   data-type[size];>

Dabei gibt Größe (eine Variable) die Anzahl der Elemente in einem Array an.

Beispiel:

Shehzad Poonawala

int *p = new int[10]>

Reserviert dynamisch Speicher für 10 fortlaufende Ganzzahlen vom Typ int und gibt einen Zeiger auf das erste Element der Sequenz zurück, dem top (ein Zeiger) zugewiesen ist. p[0] bezieht sich auf das erste Element, p[1] bezieht sich auf das zweite Element und so weiter.

Normale Array-Deklaration vs. Verwendung von new
Es gibt einen Unterschied zwischen der Deklaration eines normalen Arrays und der Zuweisung eines Speicherblocks mithilfe von new. Der wichtigste Unterschied besteht darin, dass die Zuordnung normaler Arrays vom Compiler aufgehoben wird (wenn das Array lokal ist, wird die Zuordnung aufgehoben, wenn die Funktion zurückkehrt oder abgeschlossen ist). Dynamisch zugewiesene Arrays bleiben jedoch immer dort, bis sie entweder vom Programmierer freigegeben werden oder das Programm beendet wird.

Warteschlange in Java

Was passiert, wenn zur Laufzeit nicht genügend Speicher verfügbar ist?
Wenn im Heap nicht genügend Speicher für die Zuweisung verfügbar ist, zeigt die neue Anforderung einen Fehler an, indem sie eine Ausnahme vom Typ std::bad_alloc auslöst, es sei denn, nothrow wird mit dem neuen Operator verwendet. In diesem Fall wird ein NULL-Zeiger zurückgegeben (scrollen Sie zum Abschnitt Ausnahme). Umgang mit neuem Betreiber in Das Artikel). Daher ist es möglicherweise eine gute Idee, die vom neuen Programm erzeugte Zeigervariable zu überprüfen, bevor Sie das Programm verwenden.

int *p = new(nothrow) int; if (!p) {  cout << 'Memory allocation failed
'; }>

Löschoperator

Da es in der Verantwortung des Programmierers liegt, dynamisch zugewiesenen Speicher freizugeben, steht Programmierern der Löschoperator in der Sprache C++ zur Verfügung.

Syntax:

// Release memory pointed by pointer-variable   delete   pointer-variable;>

Hier ist die Zeigervariable der Zeiger, der auf das von erstellte Datenobjekt zeigt neu .

Beispiele:

delete p; delete q;>

Um das dynamisch zugewiesene Array, auf das die Zeigervariable zeigt, freizugeben, verwenden Sie die folgende Form von löschen :

  // Release block of memory     // pointed by pointer-variable  delete[] pointer-variable;     Example:    // It will free the entire array    // pointed by p.   delete[] p;>

// C++ program to illustrate dynamic allocation // and deallocation of memory using new and delete #include  using namespace std; int main() {  // Pointer initialization to null  int* p = NULL;  // Request memory for the variable  // using new operator  p = new (nothrow) int;  if (!p)  cout << 'allocation of memory failed
';  else {  // Store value at allocated address  *p = 29;  cout << 'Value of p: ' << *p << endl;  }  // Request block of memory  // using new operator  float* r = new float(75.25);  cout << 'Value of r: ' << *r << endl;  // Request block of memory of size n  int n = 5;  int* q = new (nothrow) int[n];  if (!q)  cout << 'allocation of memory failed
';  else {  for (int i = 0; i < n; i++)  q[i] = i + 1;  cout << 'Value store in block of memory: ';  for (int i = 0; i < n; i++)  cout << q[i] << ' ';  }  // freed the allocated memory  delete p;  delete r;  // freed the block of allocated memory  delete[] q;  return 0; }>

Value of p: 29 Value of r: 75.25 Value store in block of memory: 1 2 3 4 5>

Zeitkomplexität: O(n), wobei n die angegebene Speichergröße ist.

In Verbindung stehende Artikel:

• Quiz zum Thema „Neu“ und „Löschen“.
• löschen vs. frei