Ce qui est l'équivalent de new/delete en C++ en C?

Ce qui est l'équivalent de new/delete en C++ en C?

Ou c'est la même chose en C/C++?

OriginalL'auteur httpinterpret | 2010-05-15

  1. 40

    Il n'y a pas new/delete expression dans C.

    L'équivalent le plus proche sont les malloc et gratuit fonctions, si vous ignorez les constructeurs/destructeurs et le type de 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;
    @KennyTM: Ne sizeof(*p) fait de déréférencement p, ou est-il tout à fait équivalente à l'écriture sizeof(int)? Il semble que dans le premier cas, cette expression pourrait provoquer une erreur de segmentation (parce que p n'est pas encore assigné à ce point). Dans ce dernier cas, je serais probablement encore préfèrent l'écriture sizeof(int) car il y a moins de risque d'incompréhension de ce que cette déclaration ne.
    Le sizeof opérateur est évaluée au moment de la compilation. Il n'y a pas de déférence. sizeof(*p) est préféré à sizeof(int) parce que si vous modifiez le type de p à double le compilateur ne peut pas vous avertir en cas d'incompatibilité de taille.
    Le sizeof opérateur est une cartographie de type pour size_t. Le valeur de son opérande n'est pas intéressant du tout. Par exemple, dans sizeof(1 + 2), il n'y a absolument pas besoin de calculer le résultat 3. Le sizeof opérateur ne voit une expression de type int + int et en déduit que le résultat est aussi une int. Puis il cartes int à 4 (ou 2 ou 8, selon la plate-forme). C'est la même chose avec sizeof(*p). Le système de type sait que, au niveau du type, référence à un int* donne une int. sizeof n'est pas intéressé par la valeur de *p à tous, seul le type de questions.
    Pour exactement la même raison, sizeof(1/0) ne se bloque PAS horriblement avec une arithmétique exception, mais au lieu de cela génère sizeof(int), parce que 1 est de type int, 0 est de type int, et la division de deux ints donne aussi un int au niveau du type. La division n'est jamais exécutée, ni au moment de la compilation, ni au moment de l'exécution!
    Merci à vous deux pour la réponse. Je pensais que je demande parce que je n'ai pas vu cette utilisation de sizeof avant. Bonne chose à savoir, si!

    OriginalL'auteur kennytm

  2. 7

    Remarque que les constructeurs pourraient lancer des exceptions en C++. L'équivalent de player* p = new player(); serait quelque chose comme ceci dans 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 doit jamais "jeter".

    destruct(p);
free(p);
    Ce serait construct_player ressembler?

    OriginalL'auteur fredoverflow

  3. 6

    Utilisation de new et delete en C++ combine deux de la responsabilité de l'allocation/libérer la mémoire dynamique, et de l'initialisation du/de relâchement d'un objet.

    Comme toutes les autres réponses-dire, de la façon la plus commune d'allouer et de libérer de la mémoire dynamique est l'appel de malloc et free. Vous pouvez également utiliser des OS des fonctions spécifiques pour obtenir une grande partie de la mémoire et de répartir des objets, mais c'est plus rare - seulement si vous en avez assez des exigences spécifiques qui malloc ne satisfait pas.

    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, le fichier api utilise une paire d'ouvrir et de fermer les fonctions:

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

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

    Il se peut que fopen utilise malloc pour allouer de l'espace de stockage pour la FILE struct, ou il peut allouer de manière statique une table pour le nombre maximal de pointeurs de fichiers sur le processus de démarrage. Le point est, les API ne nécessite pas le client à utiliser malloc et free.

    Autres Api offrent des fonctions qui vient d'effectuer l'initialisation et de libérer une partie du contrat - l'équivalent pour le constructeur et le destructeur, qui permet au client de code pour utiliser de façon automatique , en statique ou en dynamique de stockage. Un exemple est la pthreads API:

    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 a besoin de savoir la taille de la pthread_t type, tandis que si la bibliothèque gère à la fois l'allocation et initialisation le client n'a pas besoin de connaître la taille du type, de sorte que la mise en œuvre peut varier sans changement de client. N'introduit pas autant de couplage entre le client et la mise en œuvre en tant que C++ n'. (Il est souvent préférable de penser en C++ comme un modèle de la métaprogrammation langue avec les vtables qu'un langage OO)

    Pouvez-vous expliquer exactement ce que les exigences spécifiques malloc ne satisfait pas?
    alloue de la mémoire. operator new (généralement) alloue de la mémoire et initialise la mémoire pour contenir les valeurs fournies par le constructeur de la classe de l'objet spécifié. ( il y a une variable de operator new appelé "mise en place de nouveaux" qui ne fait pas allouer de la mémoire, de sorte que vous pouvez utiliser malloc pour la première partie, et de nouveau pour la deuxième, si vous le désirez)

    OriginalL'auteur Pete Kirkham

  4. 3

    Pas directement une réplique exacte mais compatible équivalents sont malloc et free.

    <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 mémoire de taille, vous pouvez utiliser sizeof opérateur.

    Si vous voulez travailler avec des tableaux multidimensionnels, vous aurez besoin d'utiliser à plusieurs reprises (comme neuf):

    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
    En C, vous n'avez pas besoin de jeter de void* vers d'autres pointeurs. Juste son int* p = malloc( sizeof(int) * cElements);
    Chris: vous Êtes sûr? Je n'ai pas travaillé avec C pour un certain temps maintenant, mais autant que je me souvienne, j'ai eu à le faire parce que le type de retour de malloc est void *.
    En c void* convertit automatiquement pour les autres types de pointeur. Casting le retour de malloc peut provoquer des erreurs si vous n'avez pas inclus stdlib.h, que les paramètres ont été pris en charge pour être int.
    Explicitement la conversion de void* à d'autres types de pointeur est nécessaire en C++ mais pas en C.
    Merci. Il semble que je suis devenu rouille C 😉

    OriginalL'auteur Gaurav Vaish

  5. 2

    Utiliser malloc /free fonctions.

    OriginalL'auteur Ashish Jindal