Qual è l'equivalente di new/delete di C++ in C?

Question

Qual è l'equivalente di new/delete di C++ in C?

Oppure è lo stesso in C/C++?

Answer 1

Non c'è new/delete espressione in C.

L'equivalente più vicino è il malloc and free functions, se si ignorano i costruttori/distruttori e la sicurezza di tipo.

#include <stdlib.h> 

int* p = malloc(sizeof(*p)); // int* p = new int; 
... 
free(p);      // delete p; 

int* a = malloc(12*sizeof(*a)); // int* a = new int[12]; 
... 
free(a);       // delete[] a; 

Answer 2

Non direttamente una replica esatta ma equivalenti compatibili sono malloc e gratuiti.

<data-type>* variable = (<data-type> *) malloc(memory-size); 
free(variable); 

Nessun costruttori/distruttori - C in ogni caso non li hanno :)

Per ottenere la memoria di dimensioni, è possibile utilizzare sizeof operatore.

Se si desidera lavorare con array multidimensionali, è necessario utilizzare più volte (come nuovo):

int** ptr_to_ptr = (int **) malloc(12 * sizeof(int *)); //assuming an array with length 12. 
ptr[0] = (int *) malloc(10 * sizeof(int)); //1st element is an array of 10 items 
ptr[1] = (int *) malloc(5 * sizeof(int)); //2nd element an array of 5 elements etc 

Answer 3

uso/funzioni malloc liberi.

Answer 4

Si noti che i costruttori possono generare eccezioni in C++. L'equivalente di player* p = new player(); sarebbe qualcosa di simile in C.

struct player *p = malloc(sizeof *p); 
if (!p) handle_out_of_memory(); 
int err = construct_player(p); 
if (err) 
{ 
    free(p); 
    handle_constructor_error(); 
} 

L'equivalente di delete p è più semplice, perché i distruttori non dovrebbero mai "tiro".

destruct(p); 
free(p); 

Answer 5

Uso di new e delete in C++ combina due responsabilità - allocazione/rilascio memoria dinamica, e inizializzazione/rilascio di un oggetto.

Come tutte le altre risposte dicono, il modo più comune per allocare e rilasciare la memoria dinamica è chiamare malloc e free. È anche possibile utilizzare funzioni specifiche del sistema operativo per ottenere una grande quantità di memoria e allocare gli oggetti in questo, ma ciò è più raro - solo se si hanno requisiti abbastanza specifici che malloc non soddisfa.

In C, la maggior parte delle API fornirà una coppia di funzioni che soddisfano gli altri ruoli di new e delete.

Ad esempio, il file API utilizza una coppia di funzioni di apertura e chiusura:

// C++ 
fstream* fp = new fstream("c:\\test.txt", "r"); 
delete fp; 

// C 
FILE *fp=fopen("c:\\test.txt", "r"); 
fclose(fp); 

può essere che fopen utilizza malloc per allocare la memoria per la FILE struct, oppure può assegnare staticamente un tavolo per il numero massimo di puntatori di file all'avvio del processo. Il punto è che l'API non richiede che il client utilizzi malloc e free.

Altre API forniscono funzioni che eseguono solo l'inizializzazione e il rilascio di parte del contratto, equivalenti al costruttore e al distruttore, che consente al codice client di utilizzare l'archiviazione automatica, statica o dinamica.Un esempio è l'API pthreads:

pthread_t thread; 

pthread_create(&thread, NULL, thread_function, (void*) param); 

Questo permette al cliente una maggiore flessibilità, ma aumenta l'accoppiamento tra la biblioteca e il cliente - il cliente ha bisogno di conoscere la dimensione del tipo pthread_t, mentre se la libreria gestisce sia allocazione e inizializzazione il client non ha bisogno di conoscere la dimensione del tipo, quindi l'implementazione può variare senza cambiare il client. Né introduce tanto l'accoppiamento tra il client e l'implementazione come fa il C++. (Spesso è meglio pensare a C++ come un linguaggio di metaprogrammazione di template con vtables rispetto a un linguaggio OO)