Namespaces
Variants

calloc

From cppreference.net
C
Dynamic memory management
Défini dans l'en-tête <stdlib.h>
void * calloc ( size_t num, size_t size ) ;

Alloue de la mémoire pour un tableau de num objets de size et initialise tous les octets de la mémoire allouée à zéro.

Si l'allocation réussit, retourne un pointeur vers l'octet le plus bas (premier) dans le bloc de mémoire alloué qui est correctement aligné pour tout type d'objet avec alignement fondamental .

Si size est zéro, le comportement est défini par l'implémentation (un pointeur nul peut être retourné, ou un pointeur non nul pouvant ne pas être utilisé pour accéder au stockage peut être retourné).

calloc est thread-safe : il se comporte comme s'il n'accédait qu'aux emplacements mémoire visibles via son argument, et non à un stockage statique.

Un appel précédent à free , free_sized , et free_aligned_sized (depuis C23) ou realloc qui désalloue une région de mémoire synchronise-avec un appel à calloc qui alloue la même région ou une partie de la même région de mémoire. Cette synchronisation se produit après tout accès à la mémoire par la fonction de désallocation et avant tout accès à la mémoire par calloc . Il existe un ordre total unique pour toutes les fonctions d'allocation et de désallocation opérant sur chaque région de mémoire particulière.

(depuis C11)

Table des matières

Paramètres

num - nombre d'objets
size - taille de chaque objet

Valeur de retour

En cas de succès, retourne le pointeur vers le début de la mémoire nouvellement allouée. Pour éviter une fuite de mémoire, le pointeur retourné doit être désalloué avec free() ou realloc() .

En cas d'échec, retourne un pointeur nul.

Notes

En raison des exigences d'alignement, le nombre d'octets alloués n'est pas nécessairement égal à num * size .

L'initialisation de tous les bits à zéro ne garantit pas qu'un nombre à virgule flottante ou un pointeur serait initialisé à 0.0 et la valeur du pointeur nul, respectivement (bien que cela soit vrai sur toutes les plateformes courantes).

À l'origine (en C89), la prise en charge de la taille zéro a été ajoutée pour accommoder du code tel que 

OBJ* p = calloc(0, sizeof(OBJ)); // espace réservé de "longueur nulle"
...
while(1)
{
    p = realloc(p, c * sizeof(OBJ)); // réallocations jusqu'à stabilisation de la taille
    ... // code susceptible de modifier c ou de sortir de la boucle
}

Exemple

Exécuter ce code 
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
    int* p1 = calloc(4, sizeof(int));    // alloue et initialise à zéro un tableau de 4 entiers
    int* p2 = calloc(1, sizeof(int[4])); // identique, en nommant directement le type de tableau
    int* p3 = calloc(4, sizeof *p3);     // identique, sans répéter le nom du type
    if (p2)
    {
        for (int n = 0; n < 4; ++n) // affiche le tableau
            printf("p2[%d] == %d\n", n, p2[n]);
    }
    free(p1);
    free(p2);
    free(p3);
}

Sortie : 

p2[0] == 0
p2[1] == 0
p2[2] == 0
p2[3] == 0

Références

  • Norme C23 (ISO/IEC 9899:2024):
  • 7.22.3.2 La fonction calloc (p: TBD)
  • Norme C17 (ISO/CEI 9899:2018) :
  • 7.22.3.2 La fonction calloc (p : 253)
  • Norme C11 (ISO/CEI 9899:2011):
  • 7.22.3.2 La fonction calloc (p: 348)
  • Norme C99 (ISO/CEI 9899:1999) :
  • 7.20.3.1 La fonction calloc (p: 313)
  • Norme C89/C90 (ISO/IEC 9899:1990) :
  • 4.10.3.1 La fonction calloc

Voir aussi

Documentation C++ pour calloc