Espacios de nombres
Variantes
Acciones

calloc

De cppreference.com
< c‎ | memory
Definido en la cabecera <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)

Contenido

[editar] Parametros

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

[editar] 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.

[editar] 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
}

[editar] Ejemplo

#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

[editar] 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

[editar] Véase también