Wo kann man in einem C -Programm frei setzen
Wo man Free () in einem C -Programm festlegen kann?
Verwendung frei() Dynamic Memory zu beenden ist ein kritischer Teil beim Schreiben eines gut strukturierten C-Programms. Dies kann häufig auf Speicherbezogene Probleme wie Segmentierungsfehler, Speicherlecks und Speicherfragmentierung verhindern. Da der Vorgang des Programms von der Zuweisung und Deallokation von Speicherblöcken korrekter Größe zum richtigen Zeitpunkt abhängt, ist es wichtig, die zu verwenden frei() auf angemessene Weise funktionieren. Wenn der Speicher nicht korrekt freigegeben wird, kann dies dazu führen, dass der Speicher eingeschlossen ist, wodurch das Programm nicht wie erwartet ausgeführt wird.
Es gibt mehrere Orte, an denen Sie die festlegen können frei() In einem C -Programm und die Details werden unten erörtert.
1: Ende eines C -Programms
Der frei() Die Funktion kann am Ende eines C -Programms platziert werden, nachdem die Speicherzuweisungen abgeschlossen sind. Dies stellt sicher, dass der Speicher nach Abschluss des Programms verhandelt wird und dass keine Probleme mit dem Speicherlaughemmer auftreten werden. Außerdem die frei() Die Funktion sollte vorhanden sein, wenn das Programm beendet ist.
#enthalten
#enthalten
int main ()
int *ptr1;
int n = 6;
ptr1 = (int *) malloc (n * sizeof (int));
if (ptr1 == null)
printf ("Fehler: Speicherzuweisung fehlgeschlagen \ n");
Ausgang (1);
für (int i = 0; i < n; i++)
*(ptr1 + i) = i;
printf ("%d", *(ptr1 + i));
frei (ptr1);
Rückkehr 0;
Im obigen Code verwenden wir zunächst zuerst malloc () Um Speicher zuzuweisen, nutzen wir ihn, um einige Zahlen zu speichern. Wir benutzen das frei() Funktionieren Sie den Speicher am Ende des Programms.
Ausgang
Wenn der frei() Die Funktion wird nicht verwendet, wenn das Programm ausgeht, und es können unvorhersehbare Ergebnisse auftreten, z. Daher ist es wichtig, die strategisch zu platzieren frei() entsprechend funktionieren.
2: Vor dem Ende der Schleife
Schließlich ist es Best Practice, das zu platzieren frei() Funktion vor dem Ende einer Schleife, um den Speicher vor der Schleife zu bearbeiten, bevor die Schleife erneut ausgeführt wird. Auf diese Weise wird das Programm nicht mit der Aufgabe belastet, wiederholt den Speicher in einem abschließenden Codeabschnitt zuzuweisen und zu behandeln.
#enthalten
#enthalten
int main ()
int *ptr;
int n = 4;
für (int i = 0; i < n; i++)
ptr = (int*) malloc (sizeof (int));
if (ptr == null)
printf ("Fehler: Speicherzuweisung nicht erfolgreich \ n");
Ausgang (1);
*ptr = i;
printf ("%d", *ptr);
frei (ptr);
Rückkehr 0;
Im obigen Beispiel verwenden wir die malloc () Funktion innerhalb der Schleife, um Speicher zuzuweisen, mit dem anschließend eine einzige Ganzzahl gespeichert wird. Wir nennen frei() um das Gedächtnis am Ende jeder Iteration der Schleife zu bearbeiten. Dies verhindert potenzielle Speicherlecks, die auftreten würden, wenn der Speicher am Ende des Programms nicht verhandelt würde, und garantiert, dass er für nachfolgende Teile des Programms zugänglich ist.
Ausgang
Notiz: Es ist entscheidend zu beachten. Der Speicher sollte dann freigegeben werden, wenn Sie fertig sind.
3: Im Fehlerfall
Schließlich sollte darauf geachtet werden, dass jeder in einem Programm zugewiesene Speicher, wenn das Programm endet, veröffentlicht wird, auch wenn ein unerwarteter Fehler auftritt. Wenn ein Fehler auftritt, sollte besondere Sorgfalt auftreten, um sicherzustellen.
#enthalten
#enthalten
int main ()
int *ptr1, *ptr2;
ptr1 = (int*) malloc (sizeof (int));
if (ptr1 == null)
printf ("Fehler: Speicherzuweisung nicht erfolgreich \ n");
Ausgang (1);
ptr2 = (int *) malloc (3 * sizeof (int));
if (ptr2 == null)
printf ("Fehler: Speicherzuweisung nicht erfolgreich \ n");
frei (ptr1);
Ausgang (1);
frei (ptr1);
frei (ptr2);
Rückkehr 0;
In diesem Beispiel wird der Speicher mithilfe der Vermittlung zugewiesen malloc (), und nach jeder Zuordnung werden Fehler überprüft. Wir verwenden frei() Um einen Speicher zu veröffentlichen, der zuvor zugewiesen wurde, wenn ein Fehler vor dem Herunterfahren der Anwendung auftritt. Um Speicherlecks zu verhindern, geben wir zusätzlich alle zugewiesenen Speicher vor, bevor das Programm endet.
Ausgang
4: Im selben Block, in dem der Speicher zugewiesen wurde
Um sicherzustellen, dass das Speicher rechtzeitig veröffentlicht wird, sollten alle Codeblöcke, die dynamische Speicherzuweisungen verwenden. Dies bedeutet, dass, wenn der Speicher in einem bestimmten Codeblock zugewiesen wird, ein Anruf an frei() sollte auch in denselben Codeblock platziert werden, um sicherzustellen, dass Arrays, Zeichenfolgen oder andere Datenstrukturen nicht mehr benötigt werden.
#enthalten
#enthalten
int main ()
int n = 5;
int *ptr = (int *) malloc (n *sizeof (int));
if (ptr == null)
printf ("Fehler: Speicherzuweisung nicht erfolgreich \ n");
Ausgang (1);
für (int i = 0; i < n; i++)
*(ptr + i) = i;
printf ("%d", *(ptr + i));
frei (ptr);
Rückkehr 0;
Das obige Beispiel verwendet einen Codeblock, um den Speicher mit dem zuzuweisen malloc () Funktion, mit der dann eine Reihe von Zahlen gespeichert wird. Verwendung frei(), Wir geben dann den Speicher in der Schlussfolgerung des Blocks frei. Wir können den Speicher nicht außerhalb des Blocks verwenden oder freigeben, da er nur innerhalb der Grenzen des Blocks gültig ist.
Ausgang
Notiz: Denken Sie daran, nur zu verwenden frei() im Speicher, der dynamisch zugewiesen wurde, z. B. die Verwendung malloc (), CALLOC (), oder realloc (). Es kann ein Segmentierungsfehler oder andere Probleme auftreten, wenn Sie versuchen, Speicher zu veröffentlichen, der seit dem Verhalten Ihrer Anwendung in diesem Fall nicht dynamisch zugewiesen wurde.
Abschließende Gedanken
Der frei() Die Funktion sollte sorgfältig in ein C-Programm aufgenommen werden. Dies beinhaltet die Verwendung der frei() Funktion am Ende des Programms, im selben Block, in dem der Speicher zugewiesen wurde. Es sollte auch darauf geachtet werden, dass der Speicher freigegeben wird, auch wenn vor der Programmabgabe ein unerwarteter Fehler vorliegt. Durch korrektes Nutzen der frei() Funktion, ein C -Programm kann Ressourcen entsprechend nutzen, Speicherfragmentierung und Speicherlecks reduzieren und wie erwartet ausgeführt werden.