Quelle est la difference entre new/ deleteet malloc/ free?
Connexes (en double?): Dans quels cas dois-je utiliser malloc vs new?
Réponses:
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.
If ptr is NULL, no operation is performed.
newopérateur alloue de la mémoire à partir du magasin libre (également connu sous le nom de mémoire dynamique et tas .) Le C ++ 14 standard, section 3.7.4 sur Dynamic Storage dit : " Les objets peuvent être créés lors de l' exécution du programme de manière dynamique (1,9), en utilisant de nouveaux-expressions (5.3.4), et détruits à l' aide de suppression-expressions."
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.
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:
new construit l'objet en appelant le constructeur de cet objetnew ne nécessite pas de transtypage de la mémoire allouée.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.
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é.
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.new, nous pouvons passer l'adresse où nous voulons allouer de la mémoire mais ce n'est pas possible en cas de malloc.alloc.hn'est pas un en-tête standard. <new>est requis pour utiliser le placement nouveau.
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.