Espacios de nombres
Variantes

    calloc

    De cppreference.com
    < c | memory
     
    C
     
    Gestión de memoria dinámica
     
    Definido en el archivo de encabezado <stdlib.h> 
    void* calloc( size_t numero, size_t tamaño );

    Asigna memoria a un arreglo de determinado numero de objetos de determinado tamaño e inicializa todos los bytes del almacenamiento asignado a cero.

    Si la asignación tiene éxito, devuelve un puntero al byte más bajo (el primero) en el bloque de memoria asignado que está alineado adecuadamente para cualquier tipo de objeto.

    Si el tamaño es cero, el comportamiento está definido en la implementación (el puntero nulo puede ser devuelto, o algún puntero no nulo puede ser devuelto que no puede ser usado para acceder al almacenamiento)

    calloc es seguro para hilos: se comporta como si sólo accediera a las posiciones de memoria visibles a través de su argumento, y no a cualquier almacenamiento estático.

    Una llamada previa a free o realloc que desasigna una región de memoria se sincroniza con una llamada a un calloc que asigna la misma o parte de la misma región de memoria. Esta sincronización se produce después de cualquier acceso a la memoria por parte de la función de desasignación y antes de cualquier acceso a la memoria por parte de calloc. Hay un solo orden total de todas las funciones de asignación y desasignación que operan en cada región particular de la memoria.

    		(desde C11)

    Parametros

    numero - número de objetos
    tamaño - tamaño de cada objeto

    Valor de retorno

    En caso de éxito, devuelve el puntero al principio de la nueva memoria asignada. Para evitar una fuga de memoria, el puntero devuelto debe estar desasignado con free() o realloc().

    En caso de fallo, devuelve un puntero nulo.

    Observaciones

    Debido a los requisitos de alineación, el número de bytes asignados no es necesariamente igual a num*size.

    La inicialización a todos los bits cero no garantiza que una coma flotante o un puntero se inicialice su valor como 0.0 y como un puntero nulo, respectivamente (aunque esto es válido para todas las plataformas comunes).

    Originalmente (en C89), se agregó soporte para el tamaño cero para acomodar códigos tales como 

    OBJ *p = calloc(0, sizeof(OBJ)); // marcador de "longitud cero"
...
while(1) { 
    p = realloc(p, c * sizeof(OBJ)); // sigue reasignando hasta que el tamaño se ajuste
    ... // el código que puede cambiar c o salir del bucle
}

    Ejemplo

    Ejecuta este código
    #include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *p1 = calloc(4, sizeof(int));    // asigna con ceros suficiente para un arreglo de 4 int
    int *p2 = calloc(1, sizeof(int[4])); // lo mismo, nombrando el tipo directamente
    int *p3 = calloc(4, sizeof *p3);     // lo mismo, sin repetir el nombre del tipo

    if(p2) {
        for(int n=0; n<4; ++n) // imprime el arreglo
            printf("p2[%d] == %d\n", n, p2[n]);
    }

    free(p1);
    free(p2);
    free(p3);
}

    Salida: 

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

    Referencias

    • Standard C11 (ISO/IEC 9899:2011):
    • 7.22.3.2 The calloc function (p: 348)
    • Standard C99 (ISO/IEC 9899:1999):
    • 7.20.3.1 The calloc function (p: 313)
    • Standard C89/C90 (ISO/IEC 9899:1990):
    • 4.10.3.1 The calloc function

    Véase también

    Documentación de C++ para calloc