Malloc et des Pointeurs Void

Je suis étudiant cette fonction de malloc et je pourrais utiliser un peu d'aide:

static void *malloc(int size)
  {
        void *p;

        if (size < 0)
                 error("Malloc error");
        if (!malloc_ptr)
                 malloc_ptr = free_mem_ptr;

        malloc_ptr = (malloc_ptr + 3) & ~3;     /* Align */

        p = (void *)malloc_ptr;
        malloc_ptr += size;

        if (free_mem_end_ptr && malloc_ptr >= free_mem_end_ptr)
                 error("Out of memory");

        malloc_count++;
        return p;
 }

Je sais que le malloc func alloue de l'espace mémoire pour n'importe quel type, si il y a assez de mémoire, mais les lignes que je ne comprends pas:

p = (void *)malloc_ptr;
malloc_ptr += size;

Comment peut-il point à tout type de données de ce genre? Je ne peux pas comprendre que le vide de pointeur ou de son emplacement.

REMARQUE: malloc_ptr est un unsigned long

Ce code contient l'hypothèse qu'un pointeur vers unsigned long (c'est à dire malloc_ptr) peut aussi le point de tout autre objet, à partir d'un alignement de point de vue. Cette hypothèse n'est pas toujours vrai (par exemple, sur certains systèmes, il peut ne pas être en mesure de point à long double objets).
Le code suppose que personne n'a une plus strictes, de l'alignement de l'exigence que les 4 octets de l'alignement. Le code ne montre pas comment free_mem_ptr et free_mem_end_ptr sont initialisés. Il ne renvoie pas NULL quand il n'y a pas plus d'espace. Si la fonction error() retourne, puis l'enfer se déchaîne.

OriginalL'auteur morcillo | 2012-12-25

  1. 5

    La raison pour laquelle elle renvoie un pointeur void est parce qu'il n'a aucune idée de ce que vous allouer de l'espace dans le malloc appel. Tous il sait la quantité d'espace que vous avez demandé. C'est à vous ou à votre compilateur de décider de ce qui remplit la mémoire. Le vide emplacement du pointeur est généralement mis en œuvre comme une liste chaînée pour maintenir l'intégrité et de savoir quelles sont les valeurs de la mémoire sont gratuits ce qui est étonnamment gardé la trace de la free fonction.

    mais comment sait-il combien d'espace à allouer? comment faut-il utiliser la valeur de la taille? Je n'ai juste pas le voir. Par exemple, j'ai un struct avec 8 ints 3 caractères et 1 flotteur, appelé mystruct, et en théorie, il devrait allouer de l'espace mémoire pour beaucoup, mais je ne comprends juste pas comment
    Dans ce cas, vous devrez probablement utiliser le sizeof opérateur qui va déterminer la bonne taille en octets nécessaires pour bien répartir cette structure que vous avez déclaré.
    Je sais que le sizeof est pour cela, mais ce que je ne comprends pas, c'est comment fait-il pour allouer de l'espace dans la mémoire. malloc_ptr a la taille du type, mais comment p = (void *)malloc_ptr savoir pour allouer de 8 octets, soit 2 octets, soit 152 octets? le casting de la fonction de malloc qui le fait fonctionner? (my_struct *)malloc(sizeof(my_struct))??
    Dans ce cas, la fonction assigne simplement le pointeur à ce que je suis en supposant est une struct comme une adresse mémoire. Il s'étend ensuite à la taille par l'int vous passé en paramètre, et donc "s'étend" l'allocation de mémoire par size octets de retourner le premier pointeur vers cette quantité de mémoire.
    Je vous remercie beaucoup. Aujourd'hui, le concept est plus clair dans ma tête. Je vais continuer à étudier. Déjà vous a donné un chèque de bonne réponse ... j'espère que c'est un assez bon cadeau de noël.

    OriginalL'auteur squiguy

  2. 2

    C'est le mise en œuvre de malloc, de sorte qu'il est autorisé à faire des choses qui ne serait pas légitime dans un programme régulier. Plus précisément, il est fait usage de la mise en œuvre définies par la conversion de unsigned long à void *. L'initialisation du programme définit malloc_ptr à la adresse numérique d'un grand bloc de mémoire non allouée. Ensuite, lorsque vous demandez une allocation, malloc rend un pointeur en dehors de la valeur actuelle de malloc_ptr et augmente malloc_ptr par le nombre d'octets que vous avez demandé. De cette façon, la prochaine fois que vous appelez malloc il sera de retour un nouveau pointeur.

    C'est le plus simple possible la mise en œuvre de malloc. Plus particulièrement, il semble ne jamais réutiliser la mémoire libérée.

    OriginalL'auteur zwol

  3. 1

    Malloc retourne un pointeur pour un morceau de complètement déstructurée, plat mémoire. Le (void * pointeur signifie qu'il n'a aucune idée de ce qu'il désigne (pas de structure), simplement qu'il pointe vers la mémoire de taille de taille.

    À l'extérieur de votre appel à malloc, vous pouvez dire à votre programme de ce pointeur a une certaine structure. I. e., si vous avez une structure some_struct vous pouvez dire: struct some_struct *pStruct = (struct some_struct *) malloc(sizeof(struct some_struct)).

    Voir comment malloc ne connaît que la taille de ce qu'il va allouer, mais ne savent pas en réalité une structure? Votre appel à malloc est en passant d'aucune information sur la structure, simplement la taille de la quantité de mémoire à allouer.

    C'est le C de la manière d'être générique: malloc renvoie un certain montant de mémoire et c'est votre travail de le jeter aux de la structuration de la mémoire dont vous avez besoin.

    OriginalL'auteur DWright

  4. 1
     p = (void *)malloc_ptr;

`malloc` returns a void pointer, which indicates that it is a pointer to a region of 
 unknown  data type. The use of casting is only required in C++ due to the strong type 
 system, whereas this is not the case in C. The lack of a specific pointer type 
 returned from `malloc` is `type-unsafe` behaviour according to some programmers: 
 malloc allocates based on byte count but not on type.

 malloc_ptr += size;

 `C` implicitly casts from and to `void*`, so the cast will be done automatically. In 
 `C++` only conversion to void* would be done implicitly, for the other direction an 
 explicit cast is required.

    Wiki explication sur le type coulée,

    `malloc` function returns an untyped pointer type `void *`, which the calling code must 
 cast to the appropriate pointer type. Older C specifications required an explicit cast 
 to do so, therefore the code `(struct foo *) malloc(sizeof(struct foo))` became the 
 accepted practice. However, this practice is discouraged in ANSI C as it can mask a   
 failure to include the header file in which `malloc` is defined, resulting in 
 downstream errors on machines where the int and pointer types are of different sizes, 
 such as the now-ubiquitous x86_64 architecture. A conflict arises in code that is 
 required to compile as C++, since the cast is necessary in that language.

    OriginalL'auteur Sunil Bojanapally

  5. 1

    Comme vous le voyez, ces deux lignes,

    p = (void *)malloc_ptr;
malloc_ptr += size;

    ici, vous rencontrez des malloc_ptr de type unsigned long donc nous sommes de conversion de type de cette variable de type void et puis le stocker dans p.
    et de manière similaire deuxième est la dénotation de l'malloc_ptr = malloc_ptr + taille;

    Et ce les deux codes sont pour développeur comfortness que p est de type void pointeur donc, en application lorsque vous utilisez la fonction malloc vous ne savez pas quel type de bloc de mémoire sont à renvoyer par la fonction de sorte que cette fonction est toujours revient cette générique void pointeur de sorte que nous sommes en mesure de transtypage de nouveau dans notre application, selon l'exigence.

    et même dans le deuxième code, si vous entrez la taille en négatif, ce qui se passe avec cette condition 

    if (free_mem_end_ptr && malloc_ptr >= free_mem_end_ptr)
error("Out of memory");

    OriginalL'auteur ravi bhuva