Quelle est la différence entre new
/ delete
et malloc
/ free
?
Related (duplicate?): Dans quels cas est-ce que j’utilise malloc vs new?
Tableau comparatif des fonctionnalités:
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 comstackr | 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
Techniquement, la mémoire allouée par new provient du “Free Store” tandis que la mémoire allouée par malloc provient du “Heap”. Si ces deux zones sont identiques, c’est une implémentation détaillée, ce qui est une autre raison pour laquelle malloc et new ne peuvent pas être mélangés.
La différence la plus importante est que le new
opérateur alloue de la mémoire puis appelle le constructeur et que la delete
appels du destructeur désalloue la mémoire.
new
appelle le moteur de l’object, delete
appel du dtor.
malloc
& free
alloue et libère de la mémoire brute.
Dans C ++ new
/ delete
appelez le constructeur / destructeur en conséquence.
malloc
/ free
alloue simplement de la mémoire à partir du tas. new
/ delete
alloue également de la mémoire.
new
/ delete
est C ++, malloc
/ free
vient du bon vieux C.
En C ++, new
appelle un constructeur d’objects et delete
le destructeur.
malloc
et free
, provenant des âges sombres avant OO, allouent et libèrent uniquement la mémoire, sans exécuter aucun code de l’object.
Les seules similitudes sont que malloc
/ new
retourne tous les deux un pointeur qui traite de la mémoire sur le tas, et tous deux garantissent qu’une fois un tel bloc de mémoire retourné, il ne sera plus retourné, sauf si vous le libérez / le supprimez d’abord. C’est-à-dire qu’ils allouent tous deux de la mémoire.
Cependant, new
/ delete
effectue en outre d’autres travaux arbitraires, via des constructeurs, des destructeurs et des surcharges d’opérateurs. malloc
/ free
ne peut jamais allouer et libérer de la mémoire.
En fait, new
est suffisamment personnalisable pour ne pas renvoyer nécessairement de la mémoire depuis le tas ou même allouer de la mémoire. Cependant, le new
par défaut le fait.
Il y a quelques petites choses que ne fait pas malloc
:
new
construit l’object en appelant le constructeur de cet object new
ne nécessite pas de typage de la mémoire allouée. Donc, si vous utilisez malloc
, alors vous devez faire plus de choses explicitement, ce qui n’est pas toujours pratique. De plus, new
peut être surchargé mais malloc
ne peut pas l’être.
En un mot, si vous utilisez C ++, essayez d’utiliser new
autant que possible.
La principale différence entre new et malloc est que new appelle le constructeur de l’object et l’appel correspondant à la suppression appelle le destructeur de l’object.
Il y a d’autres différences:
new
est type-safe, malloc
renvoie des objects de type void*
new
renvoie une exception en cas d’erreur, malloc
renvoie NULL
et définit errno
new
est un opérateur et peut être surchargé, malloc
est une fonction et ne peut pas être surchargé
new[]
, qui alloue des tableaux, est plus intuitif et plus sûr que malloc
Les allocations de malloc
peuvent être redimensionnées via realloc
, les new
allocations dérivées ne peuvent pas être redimensionnées
malloc
peut allouer un morceau de mémoire de N octets, il faut demander à new
d’allouer un tableau de types de caractères, par exemple
En regardant les différences, un résumé est malloc C-esque, new est C ++ – esque. Utilisez celui qui convient à votre base de code.
Bien qu’il soit légal d’implémenter new et malloc en utilisant différents algorithmes d’allocation de mémoire, sur la plupart des systèmes, new est implémenté en interne en utilisant malloc, sans aucune différence au niveau du système.
aussi,
le global new et delete peuvent être surchargés, malloc / free ne peut pas.
plus de nouveau et supprimer peut être remplacé par type.
new
et delete
sont des primitives C ++ qui déclarent une nouvelle instance d’une classe ou la suppriment (invoquant ainsi le destructeur de la classe pour l’instance).
malloc
et free
sont des fonctions C et allouent et libèrent des blocs de mémoire (en taille).
Les deux utilisent le tas pour effectuer l’allocation. malloc
et free
sont néanmoins plus “bas niveau”, car ils réservent juste un espace mémoire qui sera probablement associé à un pointeur. Aucune structure n’est créée autour de cette mémoire (sauf si vous considérez un tableau C comme une structure).
new et delete sont des opérateurs en c ++; qui peut être surchargé aussi. malloc et free sont des fonctions dans c;
malloc renvoie la valeur null ptr en cas d’échec alors que le nouveau génère une exception.
L’adresse renvoyée par malloc doit être de nouveau convertie car elle renvoie le (void *) malloc (taille) Nouveau renvoie le pointeur tapé.
malloc()
, nous devons inclure
ou
dans le programme qui n’est pas requirejs pour new
. new
et delete
peuvent être surchargés mais malloc
ne peut pas. new
, on peut passer l’adresse où on veut allouer de la mémoire mais ce n’est pas possible en cas de malloc
. Ce code d’utilisation du mot-clé delete ou de la fonction free. Mais lorsque vous créez un object pointeur à l’aide de «malloc» ou «new» et de la mémoire object de désaffectation à l’aide de delete, même ce pointeur d’object peut être une fonction d’appel dans la classe. Après cela, utilisez free au lieu de delete, mais cela fonctionne aussi après une instruction free, mais lorsque vous utilisez les deux, alors seul l’object pointeur ne peut pas appeler pour fonctionner en classe. Le code est le suivant:
#include using namespace std; class ABC{ public: ABC(){ cout<<"Hello"<disp(); cout<disp(); ABC(); cout<
sortie:
Hello Hi 0x2abfef37cc20
1.nouveau syntex est plus simple que malloc ()
2.new/delete est un opérateur où malloc () / free () est une fonction.
3.new/delete s’exécute plus vite que malloc () / free () car le nouveau code assemly est directement collé par le compilateur.
4.nous pouvons changer le sens nouveau / supprimer dans le programme à l’aide de la surcharge de l’opérateur.