Qual è la differenza tra new / delete e malloc / free?

Qual è la differenza tra new/ deletee malloc/ free?

Correlato (duplicato?): In quali casi utilizzo malloc vs new?

Nuovo / Elimina

• Alloca / rilascia memoria
  1. Memoria allocata da "Negozio gratuito"
  2. Restituisce un puntatore completamente digitato.
  3. nuovo (versione standard) non restituisce mai un NULL (genererà un errore)
  4. Sono chiamati con Type-ID (il compilatore calcola la dimensione)
  5. Ha una versione esplicitamente per gestire le matrici.
  6. Riallocazione (per ottenere più spazio) non gestita in modo intuitivo (a causa del costruttore di copie).
  7. Se chiamano malloc / free viene definita l'implementazione.
  8. Può aggiungere un nuovo allocatore di memoria per gestire la memoria insufficiente (set_new_handler)
  9. l'operatore new / delete può essere sostituito legalmente
  10. costruttore / distruttore utilizzato per inizializzare / distruggere l'oggetto

malloc / gratuito

• Alloca / rilascia memoria
  1. Memoria allocata da "Heap"
  2. Restituisce un vuoto *
  3. Restituisce NULL in caso di errore
  4. È necessario specificare la dimensione richiesta in byte.
  5. L'allocazione dell'array richiede il calcolo manuale dello spazio.
  6. Riassegnazione semplice di un grosso pezzo di memoria (nessun costruttore di copie di cui preoccuparsi)
  7. Essi non chiamare new / delete
  8. Non è possibile combinare il codice utente nella sequenza di allocazione per aiutare con memoria insufficiente.
  9. malloc / free NON può essere sostituito legalmente

Tabella comparativa delle caratteristiche:

 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                            

Tecnicamente la memoria allocata da new proviene dal 'Free Store' mentre la memoria allocata da malloc proviene da 'Heap'. Se queste due aree sono uguali è un dettaglio di implementazione, che è un'altra ragione per cui malloc e new non possono essere mescolati.

La differenza più rilevante è che l' newoperatore alloca la memoria, quindi chiama il costruttore e deletechiama il distruttore, quindi disloca la memoria.

newchiama il ctor dell'oggetto, deletechiama il dtor.

malloce freebasta allocare e rilasciare la memoria grezza.

new/ deleteè C ++, malloc/ freeviene dal buon vecchio C.

In C ++, newchiama un costruttore di oggetti e deletechiama il distruttore.

malloce free, proveniente dai secoli bui prima di OO, alloca e libera solo la memoria, senza eseguire alcun codice dell'oggetto.

In C ++ new/ deletechiama il Costruttore / Distruttore di conseguenza.

malloc/ freealloca semplicemente la memoria dall'heap. new/ deletealloca anche la memoria.

Le uniche somiglianze sono che malloc/ newentrambi restituiscono un puntatore che indirizza un po 'di memoria sull'heap, ed entrambi garantiscono che una volta che tale blocco di memoria è stato restituito, non verrà restituito di nuovo a meno che non lo si liberi / lo si elimini prima. Cioè, entrambi "allocano" la memoria.

Tuttavia, new/ deleteeseguire altri lavori arbitrari in aggiunta, tramite costruttori, distruttori e sovraccarico dell'operatore. malloc/ freesolo allocare e liberare memoria.

In effetti, newè sufficientemente personalizzabile da non necessariamente restituire memoria dall'heap, né allocare memoria affatto. Tuttavia, l'impostazione predefinita lo newfa.

La differenza principale tra new e malloc è che new invoca il costruttore dell'oggetto e la corrispondente chiamata per eliminare invoca il distruttore dell'oggetto.

Ci sono altre differenze:

• newè sicuro, mallocrestituisce oggetti di tipovoid*

• newgenera un'eccezione in caso di errore, mallocrestituisce NULLe imposta errno

• newè un operatore e può essere sovraccaricato, mallocè una funzione e non può essere sovraccaricato

• new[], che alloca le matrici, è più intuitivo e sicuro rispetto al tipo di malloc

• mallocle allocazioni derivate possono essere ridimensionate tramite realloc, le newallocazioni derivate non possono essere ridimensionate

• mallocpuò allocare un pezzo di memoria N-byte, newdeve essere richiesto di allocare un array di, diciamo, chartipi

Guardando le differenze, un riassunto è che malloc è C-esque, nuovo è C ++ - esque. Usa quello che sembra giusto per la tua base di codice.

Sebbene sia legale implementare new e malloc usando diversi algoritmi di allocazione della memoria, sulla maggior parte dei sistemi i nuovi sono implementati internamente usando malloc, senza produrre alcuna differenza a livello di sistema.

Ci sono alcune cose che newnon lo mallocfanno:

1. new costruisce l'oggetto chiamando il costruttore di quell'oggetto
2. new non richiede il typecasting della memoria allocata.
3. Non richiede l'allocazione di una quantità di memoria, ma richiede la creazione di un numero di oggetti.

Quindi, se usi malloc, allora devi fare esplicitamente le cose sopra, il che non è sempre pratico. Inoltre, newpuò essere sovraccarico ma mallocnon può esserlo.

In una parola, se usi C ++, prova a usare newil più possibile.

anche,

il nuovo globale ed elimina possono essere ignorati, malloc / free no.

ulteriori nuovi ed eliminabili possono essere sovrascritti per tipo.

newe deletesono primitivi C ++ che dichiarano una nuova istanza di una classe o la eliminano (invocando così il distruttore della classe per l'istanza).

malloce freesono funzioni C che allocano e liberano blocchi di memoria (in dimensioni).

Entrambi utilizzano l'heap per effettuare l'allocazione. malloce freesono comunque più "a basso livello" in quanto riservano solo un pezzo di spazio di memoria che sarà probabilmente associato a un puntatore. Non vengono create strutture attorno a quella memoria (a meno che non si consideri una matrice C come una struttura).

new ed delete sono operatori in c ++; che può anche essere sovraccarico. malloc e free sono funzioni in c;

malloc restituisce null ptr quando fallisce mentre new genera un'eccezione.

l'indirizzo restituito da malloc deve essere castato di nuovo poiché restituisce il malloc (void *) (size) Nuovo restituisce il puntatore digitato.

• new è un operatore, mentre malloc () è una fucntion.
• new restituisce il tipo esatto di dati, mentre malloc () restituisce void * (puntatore di tipo void).
• malloc (), la memoria non è inizializzata e il valore predefinito è immondizia, mentre in caso di novità, la memoria è inizializzata con valore predefinito, come con 'zero (0)' nel caso in int.
• delete e free () possono essere usati entrambi per i puntatori "NULL".

• Per utilizzare il malloc(), dobbiamo includere <stdlib.h> o <alloc.h>nel programma per il quale non è richiesto new.
• newe deletepuò essere sovraccarico ma mallocnon può.
• Usando il posizionamento new, possiamo passare l'indirizzo dove vogliamo allocare memoria, ma questo non è possibile in caso di malloc.

Questo codice per l'uso della parola chiave delete o della funzione gratuita. Ma quando si crea un oggetto puntatore usando 'malloc' o 'nuovo' e si dealloca la memoria degli oggetti usando delete, anche quel puntatore oggetto può essere chiamato funzione nella classe. Dopodiché usa free invece di delete quindi funziona anche dopo l'istruzione free, ma quando usa entrambi allora solo l'oggetto puntatore non può chiamare per funzionare in classe .. il codice è il seguente:

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

produzione :

Hello
Hi
0x2abfef37cc20

1.nuovo sintassi è più semplice di malloc ()

2.new/delete è un operatore in cui malloc () / free () è una funzione.

3.new/delete viene eseguito più velocemente di malloc () / free () perché il nuovo codice assemly è stato incollato direttamente dal compilatore.

4.possiamo modificare il significato di nuovo / cancellare nel programma con l'aiuto dell'overlading dell'operatore.