Quelle est la différence entre new / delete et malloc / free?

Quelle est la différence entre new / delete et malloc / free ?

Related (duplicate?): Dans quels cas est-ce que j’utilise malloc vs new?

nouveau / supprimer

  • Allouer / libérer de la mémoire
    1. Mémoire allouée depuis ‘Free Store’
    2. Renvoie un pointeur entièrement typé.
    3. new (version standard) ne retourne jamais de valeur NULL (échec)
    4. Sont appelés avec Type-ID (le compilateur calcule la taille)
    5. A une version explicite pour gérer les tableaux.
    6. Réaffecter (pour obtenir plus d’espace) n’est pas géré de manière intuitive (à cause du constructeur de copie).
    7. Qu’ils appellent malloc / free est défini par l’implémentation.
    8. Peut append un nouvel allocateur de mémoire pour gérer la mémoire faible (set_new_handler)
    9. l’opérateur new / delete peut être remplacé légalement
    10. constructeur / destructeur utilisé pour initialiser / détruire l’object

malloc / gratuit

  • Alloue / libère de la mémoire
    1. Mémoire allouée de ‘Heap’
    2. Retourne un vide *
    3. Retourne NULL en cas d’échec
    4. Doit spécifier la taille requirejse en octets.
    5. Allouer un tableau nécessite un calcul manuel de l’espace.
    6. Réaffecter un gros morceau de mémoire simple (pas de constructeur de copie à se soucier)
    7. Ils n’appelleront pas new / delete
    8. Pas moyen d’épisser le code utilisateur dans la séquence d’allocation pour aider avec la mémoire faible.
    9. malloc / free NE peut PAS être remplacé légalement

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 :

  1. new construit l’object en appelant le constructeur de cet object
  2. new ne nécessite pas de typage de la mémoire allouée.
  3. Il ne nécessite pas une quantité de mémoire à allouer, mais nécessite plutôt la construction d’un certain nombre d’objects.

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é.

  • new est un opérateur, alors que malloc () est une opération.
  • new renvoie le type de données exact, tandis que malloc () renvoie void * (pointeur de type void).
  • malloc (), la mémoire n’est pas initialisée et la valeur par défaut est garbage, alors que dans le cas de new, la mémoire est initialisée avec la valeur par défaut, comme avec “zéro (0)” dans le cas sur int.
  • delete et free () les deux peuvent être utilisés pour les pointeurs ‘NULL’.
  • Pour utiliser le 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.
  • En utilisant le placement 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.