Fonction calloc

Entête à  inclure

#include <stdlib.h>  // <cstdlib> en C++

Fonction calloc

void * calloc( size_t elementCount, size_t elementSize );

Cette fonction alloue un bloc de mémoire en initialisant tous ces octets à la valeur 0. Bien que relativement proche de la fonction malloc, deux aspects les différencient :

• L'initialisation : calloc met tous les octets du bloc à la valeur 0 alors que malloc ne modifie pas la zone de mémoire.

• Les paramètres d'appels : calloc requière deux paramètres (le nombre d'éléments consécutifs à allouer et la taille d'un élément) alors que malloc attend la taille totale du bloc à allouer.

Paramètres

• elementCount: permet de spécifier le nombre d'éléments consécutifs à réserver dans le bloc de mémoire.

• elementSize : permet de fixer la taille (en nombre d'octets) d'un élément.

Au total, la zone de mémoire allouée occupera donc elementCount * elementSize octets.

Dans le cas où le bloc de mémoire ne pourrait vous être réservé (plus de mémoire disponible, par exemple), le pointer NULL vous sera retourné. On devrait normalement et systématiquement tester que l'on ait pas cette valeur. Néanmoins cela n'est pas toujours fait par les développeurs. Donc un petit conseil, utilisez au moins un assert durant les phases de développement.

Valeur de retour

Si tout ce passe bien, la fonction vous renvoie un pointeur sur la zone nouvellement allouée. Attention, ce pointeur est de type pointeur générique (void *) : si nécessaire, il est donc de votre responsabilité de "caster" votre pointeur vers un autre type (du moins si vous souhaitez ne pas avoir de warning affiché pas le compilateur, ce que je vous recommande vivement).

Exemple de code

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

#define INT_NUMBER 10

int main() {
    
    int i;
    int * pointer = (int *) calloc( INT_NUMBER, sizeof(int) );

    /* Un petit test sur le bon fonctionnement de calloc */
    assert( pointer != NULL );

    /* Le dernier élément du tableau ne sera pas affecté par la */
    /* boucle mais n'oubliez pas que calloc initialise de toute */
    /* façon à 0 chaque octet. */
    for ( i=0; i<INT_NUMBER-1; i++ ) {
        pointer[i] = i;
    }

    /* On affiche le contenu du tableau d'entier */
    /* Ce qui donne : 0 1 2 3 4 5 6 7 8 0 */
    for (i=0; i<INT_NUMBER; i++ ) {
        printf( "%d ", pointer[i] );
    }
    printf( "\n" );

    /* On libère le bloc de mémoire alloué dynamiquement */
    free( pointer );

    return 0;
}

Sujets connexes