Pourquoi malloc (0) provoque-t-il une fuite de mémoire majeure sous Windows?

malloc (0) renvoie une nouvelle adresse valide car c'est l'option qu'il a choisie parmi celles autorisées par le standard C.

7.22.3 Fonctions de gestion de la mémoire (c'est moi qui souligne)

1 L'ordre et la contiguïté du stockage alloué par appels successifs aux fonctions align_alloc, calloc, malloc et realloc est non spécifié. Le pointeur renvoyé si l'allocation réussit est convenablement aligné pour pouvoir être affecté à un pointeur vers n'importe quel type de l'objet avec une exigence d'alignement fondamentale et ensuite utilisé pour accéder à un tel objet ou à un tableau de tels objets dans l'espace alloué (jusqu'à ce que l'espace soit explicitement désalloué). La vie de un objet alloué s'étend de l'allocation jusqu'au désallocation. Chacune de ces attributions renvoie un pointeur vers un objet disjoint de tout autre objet . Le pointeur a renvoyé des points au début (adresse d'octet le plus bas) de l'espace alloué. Si la l'espace ne peut pas être alloué, un pointeur nul est renvoyé. Si la taille de l'espace demandé est nul, le comportement est défini par l'implémentation: soit un pointeur nul est renvoyé, soit le le comportement est comme si la taille était une valeur différente de zéro, sauf que le Le pointeur renvoyé ne doit pas être utilisé pour accéder à un objet.

L'implémentation sous windows choisit le second comportement. Il doit donc effectuer une allocation pour s'assurer que l'exigence apparaît immédiatement avant. Chaque pointeur valide renvoyé par une fonction d'allocation doit être disjoint de tout autre pointeur renvoyé par une fonction d'allocation.

Lecture pertinente:

• Pourquoi la valeur de retour de l'implémentation de malloc (0) -défini?

Certains systèmes renvoient simplement NULL sans rien allouer. Mais il est parfaitement légitime pour malloc d'allouer un bloc de mémoire de 0 octet et de renvoyer un pointeur vers cette mémoire. Ce bloc doit être libéré comme tout autre bloc alloué par malloc .

Lorsque vous allouez de la mémoire, il y a une certaine surcharge impliquée. Ainsi, même allouer 0 octet prend de la mémoire.

De plus, les systèmes peuvent surallouer ou avoir des restrictions d'alignement qui peuvent rendre une partie de la mémoire inutilisable après chaque allocation. Cela peut arriver ou non ici.

Dans les commentaires, vous avez mentionné que vous faites quelque chose du genre:

if (params) {
    ...free elements of params...
    free(params);
}

Au lieu de cela, vous auriez dû faire ce qui suit:

if (num_params > 0) {
    ...free elements of params...
    free(params);
}

De l'homme page:

Si la taille est 0, malloc alloue un élément de longueur nulle dans le tas et renvoie un pointeur valide vers cet élément

Et, avec la vérification valgrind pour le petit programme:

HEAP SUMMARY:
==11887==     in use at exit: 0 bytes in 0 blocks
==11887==   total heap usage: 1 allocs, 1 frees, 0 bytes allocated
==11887== 
==11887== All heap blocks were freed -- no leaks are possible

Nous avons le journal:

HEAP SUMMARY:
==11874==     in use at exit: 0 bytes in 1 blocks
==11874==   total heap usage: 1 allocs, 0 frees, 0 bytes allocated
==11874== 
==11874== 0 bytes in 1 blocks are definitely lost in loss record 1 of 1
==11874==    at 0x4C2FB0F: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)

Mais avec la fonction gratuite :

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int *p = malloc(0);

    if(!p) {
        printf("%p\n", p);
    }
    //free(p);
    return 0;
}

Comme d'autres l'ont mentionné, malloc (0) est défini par l'implémentation, un pointeur nul est renvoyé ou le comportement est comme si la taille était une valeur différente de zéro. Il s'agit clairement de la deuxième option et citant la documentation de Microsoft pour malloc

Si la taille est 0, malloc alloue un élément de longueur nulle dans le tas et renvoie un pointeur valide vers cet élément.

Ne spécifie pas les frais généraux.

Pour nous faire une idée, nous pouvons examiner l'implémentation de la glibc pour malloc.c

Même une demande de zéro octet (c'est-à-dire malloc (0)) renvoie un pointeur à quelque chose de la taille minimum allouable

Taille minimale allouée:
ptrs 4 octets: 16 octets (dont 4 overhead)
ptrs 8 octets: 24/32 octets (y compris, 4/8 overhead)