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

Quelle est la difference entre new/ deleteet malloc/ free?

Connexes (en double?): Dans quels cas dois-je utiliser malloc vs new?

nouveau / supprimer

• Allouer / libérer de la mémoire
  1. Mémoire allouée à partir de «Free Store»
  2. Renvoie un pointeur entièrement tapé.
  3. new (version standard) ne retourne jamais un NULL (lancera en cas d'échec)
  4. Sont appelés avec Type-ID (le compilateur calcule la taille)
  5. A une version explicite pour gérer les tableaux.
  6. La réallocation (pour obtenir plus d'espace) n'est pas gérée de manière intuitive (en raison du constructeur de copie).
  7. Qu'ils appellent malloc / free est défini par l'implémentation.
  8. Peut ajouter un nouvel allocateur de mémoire pour gérer la mémoire insuffisante (set_new_handler)
  9. l'opérateur new / delete peut être annulé légalement
  10. constructeur / destructeur utilisé pour initialiser / détruire l'objet

malloc / gratuit

• Alloue / libère de la mémoire
  1. Mémoire allouée à partir de «tas»
  2. Retourne un vide *
  3. Renvoie NULL en cas d'échec
  4. Doit spécifier la taille requise en octets.
  5. L'allocation de la matrice nécessite un calcul manuel de l'espace.
  6. Réallocation d'une plus grande partie de la mémoire simple (pas de constructeur de copie à vous soucier)
  7. Ils n'appelleront PAS nouveau / supprimer
  8. Aucun moyen de fusionner le code utilisateur dans la séquence d'allocation pour réduire la mémoire.
  9. malloc / free ne peut PAS être annulé légalement

Tableau de comparaison 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 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                            

Techniquement, la mémoire allouée par new provient du «Free Store» tandis que la mémoire allouée par malloc provient du «Heap». Que ces deux zones soient identiques est un détail de mise en œuvre, ce qui est une autre raison pour laquelle malloc et new ne peuvent pas être mélangés.

La différence la plus pertinente est que l' newopérateur alloue de la mémoire puis appelle le constructeur, et deleteappelle le destructeur puis libère la mémoire.

newappelle le ctor de l'objet, deleteappelez le dtor.

malloc& freejuste allouer et libérer la mémoire brute.

new/ deleteest C ++, malloc/ freevient du bon vieux C.

En C ++, newappelle un constructeur d'objets et deleteappelle le destructeur.

mallocet free, venant des âges sombres avant OO, alloue et libère uniquement la mémoire, sans exécuter aucun code de l'objet.

En C ++ new/ deleteappelez le constructeur / destructeur en conséquence.

malloc/ freealloue simplement la mémoire du tas. new/ deleteallouer de la mémoire également.

Les seules similitudes sont que malloc/ les newdeux retournent un pointeur qui adresse de la mémoire sur le tas, et ils garantissent tous les deux qu'une fois qu'un tel bloc de mémoire a été retourné, il ne sera pas renvoyé à moins que vous ne le libériez / supprimiez d'abord. Autrement dit, ils «allouent» tous les deux de la mémoire.

Cependant, new/ deleteeffectuer d'autres travaux arbitraires en plus, via les constructeurs, les destructeurs et la surcharge des opérateurs. malloc/ freeuniquement allouer et libérer de la mémoire.

En fait, newest suffisamment personnalisable pour ne pas nécessairement renvoyer de mémoire à partir du tas, ni même allouer de mémoire. Cependant, la valeur par défaut le newfait.

La principale différence entre new et malloc est que new invoque le constructeur de l'objet et l'appel correspondant à delete invoque le destructeur de l'objet.

Il existe d'autres différences:

• newest de type sécurisé, mallocrenvoie des objets de typevoid*

• newlève une exception en cas d'erreur, mallocretourne NULLet définit errno

• newest un opérateur et peut être surchargé, mallocest une fonction et ne peut pas être surchargé

• new[], qui alloue les tableaux, est plus intuitif et sûr pour les types que malloc

• malloc-les allocations dérivées peuvent être redimensionnées via realloc, new-les allocations dérivées ne peuvent pas être redimensionnées

• mallocpeut allouer un bloc de mémoire de N octets, newdoit être invité à allouer un tableau de, disons, chartypes

En regardant les différences, un résumé est malloc est C-esque, nouveau est C ++ - esque. Utilisez celui qui convient à votre base de code.

Bien qu'il soit légal d'implémenter new et malloc à l'aide d'algorithmes d'allocation de mémoire différents, sur la plupart des systèmes, new est implémenté en interne à l'aide de malloc, ne produisant aucune différence au niveau du système.

Il y a quelques choses qui newne le mallocfont pas:

1. new construit l'objet en appelant le constructeur de cet objet
2. new ne nécessite pas de transtypage de la mémoire allouée.
3. Il ne nécessite pas une quantité de mémoire à allouer, il nécessite plutôt un certain nombre d'objets à construire.

Donc, si vous utilisez malloc, vous devez faire les choses ci-dessus explicitement, ce qui n'est pas toujours pratique. De plus, newpeut être surchargé mais mallocne peut pas l'être.

En un mot, si vous utilisez C ++, essayez d'en utiliser newautant que possible.

aussi,

le nouveau global et la suppression peuvent être remplacés, malloc / free ne peut pas.

de plus en plus de nouveaux et supprimer peuvent être remplacés par type.

newet deletesont 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).

mallocet freesont des fonctions C qui allouent et libèrent des blocs de mémoire (en taille).

Les deux utilisent le tas pour effectuer l'allocation. mallocet freesont néanmoins plus "bas niveau" car ils réservent juste un morceau d'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 fonctionnent en c;

malloc retourne null ptr en cas d'échec tandis que new lève une exception.

l'adresse retournée par malloc doit être de nouveau castée par type car elle retourne le (void *) malloc (taille) New retourne le pointeur tapé.

• new est un opérateur, tandis que malloc () est une fonction.
• 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 qu'en cas de nouveau, la mémoire est initialisée avec la valeur par défaut, comme avec 'zero (0)' en cas sur int.
• delete et free () peuvent tous deux être utilisés pour les pointeurs 'NULL'.

• Pour utiliser le malloc(), nous devons inclure <stdlib.h> ou <alloc.h>dans le programme qui n'est pas requis pour new.
• newet deletepeut être surchargé mais mallocne peut pas.
• En utilisant le placement new, nous pouvons passer l'adresse où nous voulons allouer de la mémoire mais ce n'est pas possible en cas de malloc.

Ce code pour l'utilisation du mot-clé de suppression ou de la fonction gratuite. Mais lorsque vous créez un objet pointeur à l'aide de 'malloc' ou 'new' et que vous désallouez la mémoire d'objet à l'aide de la suppression, même ce pointeur d'objet peut être appelé fonction dans la classe. Après cela, utilisez free au lieu de supprimer, cela fonctionne également après l'instruction free, mais lorsque vous utilisez les deux, seul l'objet pointeur ne peut pas appeler pour fonctionner en classe. Le code est le suivant:

#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;
}

production :

Hello
Hi
0x2abfef37cc20

1.new 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 rapidement que malloc () / free () car le nouveau code d'assemblage 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.