Während bei der dynamischen Speicherzuweisung der Speicher zugewiesen wird, während die Ausführung begonnen hat. Dieser Speicher wird vom Programmierer zur Laufzeit manuell zugewiesen, was in C++ auch als Laufzeitspeicherzuweisung bezeichnet wird. Die Größe des dynamischen Speichers kann an jeder Stelle im Programm geändert werden, da wir zum Zeitpunkt der Deklaration keine fixierbare Größe nennen. Wir geben den Wert nur direkt an die Variable weiter.
Unterschied der Speicherbelegung zu normalen Variablen
Bei normalen Variablen wird der von einem Compiler zugewiesene Speicher automatisch zugewiesen und freigegeben. Wenn der Speicher vom Programmierer dynamisch zugewiesen wird, muss er dann den Speicher entfernen oder freigeben, wenn er für die weitere Ausführung des Quellcodes nicht von Nutzen ist. Diese Situation verursacht ein „Speicherleck“, wenn das Programm beendet wird, während der Speicher nicht freigegeben wird.
Operatoren für die dynamische Zuordnung
In C++ helfen zwei Operatoren bei der Speicherzuweisung und -freigabe: „new“ und „delete“, die für die bessere Zuweisung und Freigabe des Speichers verwendet werden.
Neuer Betreiber
Es bedeutet die Nachfrage nach Speicherzuweisung. Der new-Operator initialisiert den Speicher und gibt die Adresse dieses zugewiesenen Speichers an die Zeigervariable zurück, wenn genügend Speicher verfügbar ist.
Zeigerobjekt = Neu Daten - Typ ;
Betreiber löschen
Genau wie der new-Operator wird ein delete-Operator verwendet, um den zugewiesenen Speicher zu entfernen. In C++ kann der Programmierer diesen Operator für die Freigabe verwenden.
# Zeiger_Variable löschen;
Beispiel 1
In diesem Beispiel führen wir zwei Zeiger ein: Einer ist ein Zeiger vom Typ Integer und der andere ein Gleitkommazeiger. Zeiger werden initialisiert, indem ein Sternchenzeichen mit ihnen verwendet wird.
# Int * pointInt;# Float *Punktfloat;
Durch die Verwendung dieser beiden Drucker weisen wir den Speicher dynamisch zu.
Rolle von Zeigern bei der dynamischen Zuordnung:
Das Gedächtnis des Speicherplatzes wird in Form von Blöcken entwickelt. Immer wenn wir ein Programm ausführen oder eine Operation ausführen, wird der Speicher für diesen bestimmten Zweck zugewiesen. Dieser Speicher hat eine spezielle Adresse, die dem Programm zugeordnet ist, das identifiziert, welcher Prozess oder welches Programm für diesen Speicher zugelassen ist. Auf jeden Speicherschlitz wird über die Adresse zugegriffen, zu der er gehört. Diese Adresse wird also über die Zeiger gespeichert. Kurz gesagt, wir brauchen Zeiger, um auf den Speicher zuzugreifen und auf die gleiche Weise jeder Aufgabe einen bestimmten Teil des Speichers zuzuweisen. Zeiger werden benötigt, um Adressen zu speichern.
Da bei der manuellen Allokation das Schlüsselwort ‚new‘ für die dynamische Allokation von Speicher verwendet wird, wird der Speicher vom Compiler allokiert. Wir müssen zur Laufzeit keinen Speicher zuweisen. Da die dynamische Zuordnung jedoch zufällig ist, müssen wir die Zeiger identifizieren, und für den Bindungsprozess wird dieser neue Operator verwendet.
# Pointint = new int;Ebenso wird der Gleitzeiger ebenfalls gebunden. Nach dem Bindungsprozess weisen wir dem Speicher einen beliebigen Wert zu, den wir für eine beliebige Operation buchen möchten. Indem wir den Pointer deklarieren, weisen wir dem Speicher einen bestimmten Wert zu.
# *pointInt = 50;Ein Gleitkommawert für die Punktgleitkommazahlen wird ebenfalls deklariert. Anzeige der Werte nach Zuweisung.
Wie wir besprochen haben, wird der Operator „new“ zum Zuweisen verwendet, während „delete“ zum Freigeben von Speicher verwendet wird. Sobald Sie also die Aufgabe oder Operation im Code abgeschlossen haben, entfernen wir den Speicher, den wir der Aufgabe zugewiesen haben.
Es ist besser, diesen Teil des Speichers freizugeben, damit jeder andere Prozess darauf zurückgreifen kann. Wir wenden diese Zuordnung auf beide Zeiger an.
Punkt löschen schweben ; 
Sobald Sie den Code im Texteditor gespeichert haben, können Sie mit dem Ubuntu-Terminal den Quellcode in der Datei über einen g++-Compiler ausführen.
$ g++ -o mem mem.c$ ./Speicher
Bei der Ausführung sehen Sie die dem Speicher zugewiesenen Werte.
Beispiel 2
Dieses Beispiel hat die Einbeziehung der Benutzerinteraktion. Wir nehmen eine Zahlenvariable, die einen Wert vom Benutzer enthält. Dieses Programm speichert das Ergebnis im GPA der Schüler. Alle Ergebnisse werden zur Laufzeit gespeichert.
Wenn der Benutzer die Anzahl der Schüler eingibt, wird jeder Nummer Speicher zugewiesen. Hier wird ein Float-Zeiger initialisiert, der bei der Speicherzuordnung der Ergebnisse verwendet wird.
Wir nehmen den Zeiger in Gleitkommazahl, da GPA in Dezimalschreibweise ist. Wir nehmen ein Zeigertyp-Array für die GPA, da dies zu einer Reihe von Schülern führen kann.
Dieses Zeigerarray mit dem Schlüsselwort „new“ bindet die Ausführung an den Speicher. Der GPA wird für jeden Schüler eingegeben. Da wir nicht mit der Anzahl der Schüler vertraut sind, die der Benutzer hinzufügen möchte, haben wir eine for-Schleife verwendet, um die GPA bis zur eingegebenen Zahl einzugeben. Bei jeder Wiederholung der Schleife wird der Benutzer aufgefordert, das Ergebnis einzugeben, das den Schüler identifiziert. Sobald das Ergebnis gespeichert ist, werden wir wieder eine Schleife verwenden, um alle GPAs der Schüler anzuzeigen. Am Ende wird das Zeigertyp-Array gelöscht, da der Zweck der dynamischen Speicherung erfüllt wurde.
Löschen [ ] ptr ;Jetzt führen wir den oben genannten Code aus. Der Benutzer wird zunächst aufgefordert, die Anzahl der Schüler einzugeben. Dann wird der GPA für jeden Schüler eingegeben.
Beispiel 3
Dieses Beispiel verwendet die Operatoren new und delete für das Objekt der Klasse. Diese Klasse enthält eine private Variable vom Typ Integer, die das Alter speichert. Im öffentlichen Teil einer Klasse wird der Konstruktor erstellt, der das Alter auf eine Zahl „10“ initialisiert. Hier wird eine andere Funktion verwendet, die das im Konstruktor initialisierte Alter anzeigt.
Jetzt gehen wir zum Hauptprogramm für die dynamische Zuweisung. Das Objekt der Klasse wird dynamisch erstellt.
Student * ptr = Neu Schüler ( ) ; 
Wenn das Objekt gebildet wird, wird der Konstruktor automatisch implementiert. Es wird ein Funktionsaufruf durchgeführt, um das Alter zu erhalten. Dies geschieht über den ptr.
Ptr - > getAge ( ) ;Und am Ende wird die Erinnerung freigegeben.
Fazit
Die dynamische Speicherzuordnung wird bei der Ausführung zur Laufzeit durch den Programmierer statt durch den Compiler identifizierten festen Speicher zugewiesen. Diese Zuordnung erfolgt auf Zufallsbasis und kann nach ihrer Verwendung wieder aufgehoben werden. Während in den meisten Fällen vor dem Entfernen der Ausführungsprozess stoppt und diese dynamische Zuordnung dann zu Speicherlecks führt. Wir haben dieses Phänomen in verschiedenen Ansätzen im Ubuntu-Linux-System unter Verwendung der Programmiersprache C++ implementiert.