Was ist der Unterschied zwischen new
/delete
und malloc
/free
?
Verwandte (Duplikat?): In welchen Fällen verwende ich Malloc vs New?
Tabellenvergleich der Funktionen:
Feature | new/delete | malloc/free
--------------------------+--------------------------------+-------------------------------
Memory allocated from | 'Free Store' | 'Heap'
Returns | Fully typed pointer | void*
On failure | Throws (never returns NULL) | Returns NULL
Required size | Calculated by compiler | Must be specified in bytes
Handling arrays | Has an explicit version | Requires manual calculations
Reallocating | Not handled intuitively | Simple (no copy constructor)
Call of reverse | Implementation defined | No
Low memory cases | Can add a new memory allocator | Not handled by user code
Overridable | Yes | No
Use of (con-)/destructor | Yes | No
Technisch stammt der durch neu zugewiesene Speicher aus dem "Free Store", während der von malloc zugewiesene Speicher aus dem "Heap" stammt. Wenn diese beiden Bereiche gleich sind, handelt es sich um Implementierungsdetails. Dies ist ein weiterer Grund dafür, dass Malloc und Neues nicht gemischt werden können.
Der wichtigste Unterschied besteht darin, dass der Operator new
Speicher zuordnet, dann den Konstruktor aufruft und delete
den Destruktor aufruft und den Speicher freigibt.
new
ruft den ctor des Objekts auf, delete
ruft den dtor auf.
malloc
& free
ordnen Sie einfach den Rohspeicher zu und geben Sie ihn frei.
Rufen Sie in C++ new
/delete
den Konstruktor/Destruktor entsprechend auf.
malloc
/free
weist einfach Speicher aus dem Heap zu. new
/delete
weist ebenfalls Speicher zu.
new
/delete
ist C++, malloc
/free
stammt aus dem guten alten C.
In C++ ruft new
einen Objektkonstruktor und delete
den Destruktor auf.
malloc
und free
, die aus den dunklen Zeitaltern vor OO stammen, reservieren und geben nur den Speicher frei, ohne Code des Objekts auszuführen.
Die einzigen Gemeinsamkeiten bestehen darin, dass malloc
/new
beide einen Zeiger zurückgibt, der Speicher auf dem Heapspeicher anspricht, und beide garantieren, dass ein derartiger Speicherblock erst dann zurückgegeben wird, wenn er freigegeben und gelöscht wird. Das heißt, beide "belegen" den Speicher.
new
/delete
führt jedoch über Konstruktoren, Destruktoren und das Überladen von Operatoren beliebige andere Arbeiten aus. malloc
/free
reserviert immer nur Speicherplatz.
Tatsächlich ist new
so anpassbar, dass nicht unbedingt Speicherplatz aus dem Heap zurückgegeben oder überhaupt Speicherplatz zugewiesen wird. Die Standardvariable new
ist jedoch möglich.
Der Hauptunterschied zwischen new und malloc besteht darin, dass new den Konstruktor des Objekts aufruft und der entsprechende zu löschende Aufruf den Destruktor des Objekts aufruft.
Es gibt andere Unterschiede:
new
ist typsicher, malloc
gibt Objekte vom Typ void*
zurück
new
löst bei einem Fehler eine Ausnahme aus, malloc
gibt NULL
zurück und setzt errno
new
ist ein Operator und kann überladen werden, malloc
ist eine Funktion und kann nicht überladen werden
new[]
, der Arrays zuweist, ist intuitiver und typsicherer als malloc
malloc
- abgeleitete Zuordnungen können über realloc
geändert werden, new
- abgeleitete Zuordnungen können nicht geändert werden
malloc
kann einen N-Byte-Speicherblock zuweisen, new
muss aufgefordert werden, ein Array mit char
-Typen zuzuordnen
Wenn man die Unterschiede betrachtet, ist eine Zusammenfassung malloc ist C-esque, neu ist C++ - esque. Verwenden Sie diejenige, die sich für Ihre Codebasis richtig anfühlt.
Obwohl new und malloc mit unterschiedlichen Speicherzuweisungsalgorithmen implementiert werden dürfen, ist new auf den meisten Systemen intern mit malloc implementiert, sodass keine Unterschiede auf Systemebene erzielt werden.
Es gibt einige Dinge, die new
tut, die malloc
nicht tut:
new
konstruiert das Objekt durch Aufruf des Konstruktors dieses Objektsnew
erfordert keine Typumwandlung des zugewiesenen Speichers.Wenn Sie also malloc
verwenden, müssen Sie die oben genannten Dinge explizit ausführen, was nicht immer praktisch ist. Außerdem kann new
überladen sein, malloc
jedoch nicht.
Wenn Sie in einem Word C++ verwenden, versuchen Sie, möglichst viel new
zu verwenden.
ebenfalls,
das globale new und delete kann überschrieben werden, malloc/free nicht.
weitere neue und Löschungen können pro Typ überschrieben werden.
new
und delete
sind C++ primitives , die eine neue Instanz einer Klasse deklarieren oder löschen (wodurch der Destruktor der Klasse für die Instanz aufgerufen wird).
malloc
und free
sind C Funktionen und weisen Speicherblöcke (in der Größe) zu und geben sie frei.
Beide verwenden den Heap, um die Zuordnung vorzunehmen. malloc
und free
sind jedoch eher "low level", da sie nur einen Teil des Speicherplatzes reservieren, der wahrscheinlich einem Zeiger zugeordnet wird. In diesem Speicher werden keine Strukturen erstellt (es sei denn, Sie betrachten ein C-Array als Struktur).
new und delete sind Operatoren in C++; die auch überladen werden können . malloc und free funktionieren in c;
malloc gibt null ptr zurück, wenn ein Fehler auftritt, während new eine Ausnahme auslöst.
adresse, die von malloc zurückgegeben werden muss, muss vom Typ erneut umgewandelt werden, da die (void *) malloc (size)
malloc()
verwenden zu können, müssen wir include<stdlib.h>
oder <alloc.h>
im Programm verwenden, was für new
nicht erforderlich ist.new
und delete
können überladen sein, malloc
jedoch nicht.new
können wir die Adresse an die Stelle übergeben, an der Speicherplatz zugewiesen werden soll Speicherplatz zuweisen. Dies ist jedoch im Fall von malloc
nicht möglich.Dieser Code für die Verwendung des Schlüsselworts delete oder der freien Funktion. Wenn Sie jedoch ein Pointer-Objekt mit 'malloc' oder 'new' erstellen und den Objektspeicher mit Delete freigeben, kann auch dieser Objektzeiger eine Aufruffunktion in der Klasse sein. Nach , Das free anstelle von delete verwendet, funktioniert es auch nach der free-Anweisung Wenn jedoch beide verwendet werden, kann ein Zeigerobjekt keine Funktion in der Klasse ...__ aufrufen. Der Code lautet wie folgt:
#include<iostream>
using namespace std;
class ABC{
public: ABC(){
cout<<"Hello"<<endl;
}
void disp(){
cout<<"Hi\n";
}
};
int main(){
ABC* b=(ABC*)malloc(sizeof(ABC));
int* q = new int[20];
ABC *a=new ABC();
b->disp();
cout<<b<<endl;
free(b);
delete b;
//a=NULL;
b->disp();
ABC();
cout<<b;
return 0;
}
ausgabe :
Hello Hi 0x2abfef37cc20