In quali casi utilizzo malloc e / o new?

Vedo in C ++ che ci sono diversi modi per allocare e liberare dati e capisco che quando chiami mallocdovresti chiamare freee quando usi l' newoperatore dovresti accoppiarti deleteed è un errore mescolare i due (es. Chiamare free()su qualcosa che è stato creato con l' newoperatore), ma non sono chiaro quando dovrei usare malloc/ freee quando dovrei usare new/ deletenei miei programmi del mondo reale.

Se sei un esperto di C ++, per favore fammi sapere eventuali regole pratiche o convenzioni che segui al riguardo.

A meno che non sei costretto a usare C, non dovresti mai usare malloc . Usa sempre new.

Se hai bisogno di una grande mole di dati, fai qualcosa come:

char *pBuffer = new char[1024];

Fai attenzione anche se questo non è corretto:

//This is incorrect - may delete only one element, may corrupt the heap, or worse...
delete pBuffer;

Invece dovresti farlo quando elimini un array di dati:

//This deletes all items in the array
delete[] pBuffer;

La newparola chiave è il modo C ++ per farlo e farà in modo che il tuo tipo abbia il suo costruttore chiamato . La newparola chiave è anche più sicura, mentre mallocnon è affatto sicura.

L'unico modo in cui potrei pensare che sarebbe utile usarlo mallocsarebbe se avessi bisogno di cambiare la dimensione del tuo buffer di dati. La newparola chiave non ha un modo analogo come realloc. La reallocfunzione potrebbe essere in grado di estendere le dimensioni di un pezzo di memoria per te in modo più efficiente.

Vale la pena ricordare che non è possibile mescolare new/ freee malloc/ delete.

Nota: alcune risposte a questa domanda non sono valide.

int* p_scalar = new int(5);  // Does not create 5 elements, but initializes to 5
int* p_array  = new int[5];  // Creates 5 elements

La risposta breve è: non utilizzare mallocper C ++ senza una ragione davvero valida per farlo. mallocpresenta una serie di carenze quando viene utilizzato con C ++, che è newstato definito per superare.

Carenze risolte da nuove per il codice C ++

1. mallocnon è dattiloscritto in alcun modo significativo. In C ++ devi eseguire il cast del ritorno da void*. Questo potenzialmente introduce molti problemi:

   #include <stdlib.h>
   
   struct foo {
     double d[5];
   }; 
   
   int main() {
     foo *f1 = malloc(1); // error, no cast
     foo *f2 = static_cast<foo*>(malloc(sizeof(foo)));
     foo *f3 = static_cast<foo*>(malloc(1)); // No error, bad
   }
   

2. È peggio di così però. Se il tipo in questione è POD (semplici vecchi dati), è possibile utilizzarlo in modo semi-sensibile mallocper allocare memoria, come f2nel primo esempio.

   Non è così ovvio se un tipo è POD. Il fatto che sia possibile che un determinato tipo passi da POD a non-POD senza errori di compilazione risultanti e problemi potenzialmente molto difficili da eseguire il debug è un fattore significativo. Ad esempio, se qualcuno (forse un altro programmatore, durante la manutenzione, molto più tardi dovesse apportare una modifica che non causava foopiù il POD, al momento della compilazione non apparirebbe alcun errore evidente come speravi, ad esempio:

   struct foo {
     double d[5];
     virtual ~foo() { }
   };
   

   renderebbe la mallocdel f2cattivo diventare anche, senza alcuna diagnosi evidenti. L'esempio qui è banale, ma è possibile introdurre accidentalmente non-PODness molto più lontano (ad esempio in una classe base, aggiungendo un membro non-POD). Se si dispone di C ++ 11 / boost, è possibile utilizzare is_podper verificare che questo presupposto sia corretto e generare un errore se non lo è:

   #include <type_traits>
   #include <stdlib.h>
   
   foo *safe_foo_malloc() {
     static_assert(std::is_pod<foo>::value, "foo must be POD");
     return static_cast<foo*>(malloc(sizeof(foo)));
   }
   

   Sebbene boost non sia in grado di determinare se un tipo è POD senza C ++ 11 o altre estensioni del compilatore.

3. mallocritorna NULLse l'allocazione fallisce. newgetterà std::bad_alloc. Il comportamento dell'utilizzo successivo di un NULLpuntatore non è definito. Un'eccezione ha una semantica pulita quando viene generata e viene generata dalla fonte dell'errore. Avvolgere malloccon un test appropriato ad ogni chiamata sembra noioso e soggetto a errori. (Devi solo dimenticare una volta per annullare tutto quel buon lavoro). È possibile consentire a un'eccezione di propagarsi a un livello in cui un chiamante è in grado di elaborarlo in modo NULLsensato , dove è molto più difficile restituire in modo significativo. Potremmo estendere la nostra safe_foo_mallocfunzione per lanciare un'eccezione o uscire dal programma o chiamare un gestore:

   #include <type_traits>
   #include <stdlib.h>
   
   void my_malloc_failed_handler();
   
   foo *safe_foo_malloc() {
     static_assert(std::is_pod<foo>::value, "foo must be POD");
     foo *mem = static_cast<foo*>(malloc(sizeof(foo)));
     if (!mem) {
        my_malloc_failed_handler();
        // or throw ...
     }
     return mem;
   }

4. Fondamentalmente mallocè una funzionalità C ed newè una funzionalità C ++. Di conseguenza malloc, non gioca bene con i costruttori, ma considera solo l'allocazione di una parte di byte. Potremmo estendere safe_foo_malloculteriormente il nostro utilizzo al posizionamento new:

   #include <stdlib.h>
   #include <new>
   
   void my_malloc_failed_handler();
   
   foo *safe_foo_malloc() {
     void *mem = malloc(sizeof(foo));
     if (!mem) {
        my_malloc_failed_handler();
        // or throw ...
     }
     return new (mem)foo();
   }

5. La nostra safe_foo_mallocfunzione non è molto generica - idealmente vorremmo qualcosa in grado di gestire qualsiasi tipo, non solo foo. Possiamo raggiungere questo obiettivo con modelli e modelli variabili per costruttori non predefiniti:

   #include <functional>
   #include <new>
   #include <stdlib.h>
   
   void my_malloc_failed_handler();
   
   template <typename T>
   struct alloc {
     template <typename ...Args>
     static T *safe_malloc(Args&&... args) {
       void *mem = malloc(sizeof(T));
       if (!mem) {
          my_malloc_failed_handler();
          // or throw ...
       }
       return new (mem)T(std::forward(args)...);
     }
   };

   Ora, sebbene risolvendo tutti i problemi che abbiamo identificato finora, abbiamo praticamente reinventato l' newoperatore predefinito . Se hai intenzione di utilizzare malloce posizionare, newallora potresti anche usare newper cominciare!

Dal C ++ FQA Lite :

[16.4] Perché dovrei usare new invece di trustworthy old malloc ()?

FAQ: nuovo / cancella chiama il costruttore / distruttore; nuovo è sicuro, malloc no; nuovo può essere ignorato da una classe.

FQA: Le virtù della nuova menzionata dalle FAQ non sono virtù, perché costruttori, distruttori e sovraccarico dell'operatore sono spazzatura (vedi cosa succede quando non si ha la spazzatura?), E qui il problema della sicurezza del tipo è davvero minuscolo (normalmente hai per lanciare il vuoto * restituito da malloc al tipo di puntatore destro per assegnarlo a una variabile di puntatore tipizzata, che può essere fastidiosa, ma tutt'altro che "non sicura").

Oh, e l'utilizzo del vecchio malloc affidabile rende possibile l'uso del realloc altrettanto affidabile e vecchio. Peccato che non abbiamo un nuovo operatore lucido rinnovabile o qualcosa del genere.

Tuttavia, il nuovo non è abbastanza grave da giustificare una deviazione dallo stile comune usato in una lingua, anche quando la lingua è C ++. In particolare, le classi con costruttori non banali si comporteranno in modo fatale se semplicemente malifichi gli oggetti. Quindi perché non usare nuovi in ​​tutto il codice? Le persone raramente sovraccaricano l'operatore nuovo, quindi probabilmente non ti ostacolerà troppo. E se sovraccaricano di nuovo, puoi sempre chiedere loro di smettere.

Mi dispiace, non ho potuto resistere. :)

Usa sempre nuovo in C ++. Se è necessario un blocco di memoria non tipizzata, è possibile utilizzare direttamente l'operatore new:

void *p = operator new(size);
   ...
operator delete(p);

Utilizzare malloce solo per allocare memoria che verrà gestita da librerie e API c-centric. Usa e (e le varianti) per tutto ciò che controlli.free newdelete[]

new vs malloc ()

1) newè un operatore , mentre malloc()è una funzione .

2) newchiama costruttori , mentre malloc()non lo fa.

3) newrestituisce il tipo esatto di dati , mentre malloc()restituisce void * .

4) newnon restituisce mai un NULL (genererà un errore) mentre malloc()restituisce NULL

5) Riallocazione della memoria non gestita da newwhile malloc()can

Per rispondere alla tua domanda, dovresti conoscere la differenza tra mallocenew . La differenza è semplice:

malloc alloca memoria , mentre new alloca memoria E chiama il costruttore dell'oggetto per cui stai allocando memoria.

Quindi, a meno che tu non sia limitato a C, non dovresti mai usare malloc, specialmente quando hai a che fare con oggetti C ++. Sarebbe una ricetta per interrompere il tuo programma.

Anche la differenza tra freee deleteè abbastanza la stessa. La differenza è che deletechiamerà il distruttore del tuo oggetto oltre a liberare memoria.

C'è una grande differenza tra malloce new. mallocalloca memoria. Questo va bene per C, perché in C un grumo di memoria è un oggetto.

In C ++, se non hai a che fare con tipi POD (che sono simili ai tipi C) devi chiamare un costruttore in una posizione di memoria per avere effettivamente un oggetto lì. I tipi non POD sono molto comuni in C ++, poiché molte funzionalità C ++ rendono automaticamente un oggetto non POD.

newalloca memoria e crea un oggetto su quella posizione di memoria. Per i tipi non POD questo significa chiamare un costruttore.

Se fai qualcosa del genere:

non_pod_type* p = (non_pod_type*) malloc(sizeof *p);

Il puntatore che ottieni non può essere dereferenziato perché non punta a un oggetto. Dovresti chiamare un costruttore su di esso prima di poterlo usare (e questo viene fatto usando il posizionamento new).

Se invece fai:

non_pod_type* p = new non_pod_type();

Ottieni un puntatore che è sempre valido, perché ha newcreato un oggetto.

Anche per i tipi POD, c'è una differenza significativa tra i due:

pod_type* p = (pod_type*) malloc(sizeof *p);
std::cout << p->foo;

Questo pezzo di codice stamperebbe un valore non specificato, poiché gli oggetti POD creati da mallocnon vengono inizializzati.

Con new, è possibile specificare un costruttore da chiamare e quindi ottenere un valore ben definito.

pod_type* p = new pod_type();
std::cout << p->foo; // prints 0

Se lo vuoi davvero, puoi usare use newper ottenere oggetti POD non inizializzati. Vedi questa altra risposta per ulteriori informazioni al riguardo.

Un'altra differenza è il comportamento in caso di fallimento. Quando non riesce a allocare memoria, mallocrestituisce un puntatore null, mentre newgenera un'eccezione.

Il primo richiede di testare ogni puntatore restituito prima di utilizzarlo, mentre il successivo produrrà sempre puntatori validi.

Per questi motivi, nel codice C ++ è necessario utilizzare newe non malloc. Ma anche allora, non dovresti usare new"all'aperto", perché acquisisce risorse che devi rilasciare in seguito. Quando lo usi new, dovresti passare immediatamente il risultato in una classe di gestione delle risorse:

std::unique_ptr<T> p = std::unique_ptr<T>(new T()); // this won't leak

L'allocazione dinamica è richiesta solo quando il tempo di vita dell'oggetto deve essere diverso dall'ambito in cui viene creato (vale anche per rendere l'ambito più piccolo più grande) e hai un motivo specifico in cui non è memorizzato per valore lavoro.

Per esempio:

 std::vector<int> *createVector(); // Bad
 std::vector<int> createVector();  // Good

 auto v = new std::vector<int>(); // Bad
 auto result = calculate(/*optional output = */ v);
 auto v = std::vector<int>(); // Good
 auto result = calculate(/*optional output = */ &v);

Da C ++ 11 in poi, abbiamo std::unique_ptra che fare con la memoria allocata, che contiene la proprietà della memoria allocata. std::shared_ptrè stato creato per quando devi condividere la proprietà. (ti servirà meno di quanto ti aspetteresti in un buon programma)

La creazione di un'istanza diventa davvero semplice:

auto instance = std::make_unique<Class>(/*args*/); // C++14
auto instance = std::make_unique<Class>(new Class(/*args*/)); // C++11
auto instance = std::make_unique<Class[]>(42); // C++14
auto instance = std::make_unique<Class[]>(new Class[](42)); // C++11

C ++ 17 aggiunge anche std::optionalche può impedire di richiedere allocazioni di memoria

auto optInstance = std::optional<Class>{};
if (condition)
    optInstance = Class{};

Non appena "istanza" esce dall'ambito, la memoria viene ripulita. Il trasferimento della proprietà è anche facile:

 auto vector = std::vector<std::unique_ptr<Interface>>{};
 auto instance = std::make_unique<Class>();
 vector.push_back(std::move(instance)); // std::move -> transfer (most of the time)

Quindi quando hai ancora bisogno new? Quasi mai da C ++ 11 in poi. La maggior parte di essi viene utilizzata std::make_uniquefino a quando non si raggiunge un punto in cui si colpisce un'API che trasferisce la proprietà tramite puntatori non elaborati.

 auto instance = std::make_unique<Class>();
 legacyFunction(instance.release()); // Ownership being transferred

 auto instance = std::unique_ptr<Class>{legacyFunction()}; // Ownership being captured in unique_ptr

In C ++ 98/03, è necessario eseguire la gestione manuale della memoria. In questo caso, prova a passare a una versione più recente dello standard. Se sei bloccato:

 auto instance = new Class(); // Allocate memory
 delete instance;             // Deallocate
 auto instances = new Class[42](); // Allocate memory
 delete[] instances;               // Deallocate

Assicurati di monitorare correttamente la proprietà per non avere perdite di memoria! La semantica di Move non funziona ancora.

Quindi, quando avremo bisogno di malloc in C ++? L'unico motivo valido sarebbe quello di allocare memoria e inizializzarla in seguito tramite il posizionamento nuovo.

 auto instanceBlob = std::malloc(sizeof(Class)); // Allocate memory
 auto instance = new(instanceBlob)Class{}; // Initialize via constructor
 instance.~Class(); // Destroy via destructor
 std::free(instanceBlob); // Deallocate the memory

Anche se quanto sopra è valido, questo può essere fatto anche tramite un nuovo operatore. std::vectorè un buon esempio per questo.

Infine, abbiamo ancora l'elefante nella stanza: C. Se devi lavorare con una libreria C in cui la memoria viene allocata nel codice C ++ e liberata nel codice C (o viceversa), sei costretto a usare malloc / free.

Se ti trovi in ​​questo caso, dimentica le funzioni virtuali, le funzioni membro, le classi ... Sono consentite solo le strutture con POD.

Alcune eccezioni alle regole:

• Stai scrivendo una libreria standard con strutture dati avanzate in cui malloc è appropriato
• Devi allocare grandi quantità di memoria (nella copia di memoria di un file da 10 GB?)
• Hai degli strumenti che ti impediscono di usare determinati costrutti
• Devi memorizzare un tipo incompleto

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.

Se lavori con dati che non richiedono costruzione / distruzione e richiedono riallocazioni (ad es. Una vasta gamma di ints), credo che malloc / free sia una buona scelta in quanto ti dà realloc, che è molto più veloce di new-memcpy -delete (è sulla mia scatola di Linux, ma suppongo che questo possa dipendere dalla piattaforma). Se si lavora con oggetti C ++ che non sono POD e richiedono costruzione / distruzione, è necessario utilizzare gli operatori new ed delete.

Ad ogni modo, non vedo perché non dovresti usare entrambi (purché tu liberi la memoria malloced ed elimini gli oggetti allocati con nuovi) se puoi trarre vantaggio dall'aumento di velocità (a volte significativo, se stai reallando grandi array di POD) che realloc può darti.

A meno che non sia necessario, è necessario attenersi a new / delete in C ++.

Se si dispone del codice C che si desidera trasferire su C ++, è possibile lasciare qualsiasi chiamata malloc (). Per qualsiasi nuovo codice C ++, consiglierei invece di usare new.

Se stai usando C ++, prova a usare new / delete invece di malloc / calloc in quanto sono operatori. Per malloc / calloc, è necessario includere un'altra intestazione. Non mescolare due lingue diverse nello stesso codice. Il loro lavoro è simile in ogni modo, entrambi alloca la memoria in modo dinamico dal segmento heap nella tabella hash.

new inizializzerà i valori predefiniti di struct e collegherà correttamente i riferimenti in esso a se stesso.

Per esempio

struct test_s {
    int some_strange_name = 1;
    int &easy = some_strange_name;
}

Quindi new struct test_srestituirà una struttura inizializzata con un riferimento funzionante, mentre la versione malloc non ha valori predefiniti e i riferimenti interni non sono inizializzati.

Da una prospettiva inferiore, new inizializzerà tutta la memoria prima di dare memoria, mentre malloc manterrà il contenuto originale della memoria.

Nel seguente scenario, non possiamo usare new poiché chiama il costruttore.

class  B  {
private:
    B *ptr;
    int x;
public:
    B(int n)  {
        cout<<"B: ctr"<<endl;
        //ptr = new B;  //keep calling ctr, result is segmentation fault
        ptr = (B *)malloc(sizeof(B));
        x = n;
        ptr->x = n + 10;
    }
    ~B()  {
        //delete ptr;
        free(ptr);
        cout<<"B: dtr"<<endl;
    }
};

Gli operatori newe deletepossono operare su classi e strutture, mentre malloce freefunzionano solo con blocchi di memoria che devono essere espressi.

L'utilizzo new/deleteaiuterà a migliorare il codice in quanto non sarà necessario trasmettere la memoria allocata alla struttura di dati richiesta.

Caso raro da considerare l'utilizzo di malloc / free anziché new / delete è quando si allocano e quindi si riallocano (tipi di pod semplici, non oggetti) usando realloc in quanto non esiste una funzione simile a realloc in C ++ (sebbene ciò possa essere fatto usando un più approccio C ++).

malloc () è usato per assegnare dinamicamente la memoria in C mentre lo stesso lavoro è fatto da new () in c ++. Quindi non è possibile combinare convenzioni di codifica in 2 lingue. Sarebbe bello se tu chiedessi la differenza tra calloc e malloc ()