Quel est l'équivalent de new / delete de C++ en C?
Quel est l'équivalent de new / delete de C++ en C?
Ou c'est la même chose en C/C++?
5 réponses
Il n'y a pas de new/delete expression en C.
l'équivalent Le plus proche sont les malloc et free fonctions, si vous ignorez les constructeurs / destructeurs et tapez sécurité.
#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;
notez que les constructeurs peuvent lancer des exceptions en C++. L'équivalent de player* p = new player(); serait quelque chose comme ceci en 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'équivalent de delete p est plus simple, parce que les destructeurs ne devraient jamais "lancer".
destruct(p);
free(p);
new et delete EN C++ combine deux responsabilités-allouer/libérer la mémoire dynamique, et initialiser / libérer un objet.
comme toutes les autres réponses le disent, la façon la plus courante d'allouer et de libérer la mémoire dynamique est d'appeler malloc et free. Vous pouvez également utiliser des fonctions spécifiques à OS pour obtenir un grand morceau de mémoire et allouer vos objets dans cela, mais c'est plus rare-seulement si vous avez des exigences assez spécifiques que malloc ne satisfaire.
En C, la plupart des Api sera de fournir un couple de fonctions qui remplissent les autres rôles de la new et delete.
par exemple, l'api file utilise une paire de fonctions d'ouverture et de fermeture:
// C++
fstream* fp = new fstream("c:\test.txt", "r");
delete fp;
// C
FILE *fp=fopen("c:\test.txt", "r");
fclose(fp);
peut-être que fopenmalloc pour allouer le stockage pour le FILE struct, ou il peut affecter statiquement une table pour le nombre maximum de pointeurs de fichiers au démarrage du processus. Le fait est que L'API n'exige pas que le client utilise malloc et free.
D'autres API fournissent des fonctions qui ne font qu'effectuer l'initialisation et libérer une partie du contrat - équivalent au constructeur et au destructeur, ce qui permet au code client d'utiliser soit un stockage automatique , statique ou dynamique. Un exemple est l'API pthreads:
pthread_t thread;
pthread_create( &thread, NULL, thread_function, (void*) param);
cela permet au client plus de flexibilité, mais augmente le couplage entre la bibliothèque et le client - le client doit connaître la taille de la pthread_t type, alors que si la bibliothèque gère à la fois l'allocation et l'initialisation, le client n'a pas besoin de connaître la taille du type, de sorte que l'implémentation peut varier sans changer le client. Ni l'un ni l'autre n'introduit autant de couplage entre le client et l'implémentation que C++. (Il est souvent préférable de penser à C++ comme un langage de métaprogrammation de template avec vtables plutôt qu'un langage OO)
pas directement une réplique exacte mais les équivalents compatibles sont malloc et libre.
<data-type>* variable = (<data-type> *) malloc(memory-size);
free(variable);
Pas de constructeurs/destructeurs - C de toute façon ne les ai pas :)
pour obtenir la taille de la mémoire, vous pouvez utiliser sizeof opérateur.
si vous voulez travailler avec des tableaux multidimensionnels, vous devrez l'utiliser plusieurs fois (comme nouveau):
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