Namespaces
Variants

std:: calloc

From cppreference.net
< cpp ‎ | memory ‎ | c
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
Definido en el encabezado <cstdlib>
void * calloc ( std:: size_t num, std:: size_t size ) ;

Asigna memoria para un array de num objetos de tamaño size , la inicializa con todos los bits en cero ( creando implícitamente objetos en el área de destino).

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

Si size es cero, el comportamiento está definido por la implementación (puede devolverse un puntero nulo, o puede devolverse algún puntero no nulo que no pueda utilizarse para acceder al almacenamiento).

Las siguientes funciones deben ser seguras para hilos (thread-safe):

Las llamadas a estas funciones que asignan o liberan una unidad particular de almacenamiento ocurren en un único orden total, y cada llamada de liberación happens-before la siguiente asignación (si existe) en este orden.

(desde C++11)

Contenidos

Parámetros

num - número de objetos
size - tamaño de cada objeto

Valor de retorno

En caso de éxito, devuelve el puntero al inicio de la memoria recién asignada. Para evitar una fuga de memoria, el puntero devuelto debe ser liberado con std::free() o std::realloc() .

En caso de fallo, devuelve un puntero nulo.

Notas

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 en cero no garantiza que un valor de punto flotante o un puntero se inicialicen a 0.0 y al valor de puntero nulo, respectivamente (aunque esto es cierto en todas las plataformas comunes).

Originalmente (en C89), se añadió soporte para tamaño cero para adaptarse a código como 

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

Ejemplo

Ejecutar este código 
#include <cstdlib>
#include <iostream>
int main()
{
    int* p1 = (int*)std::calloc(4, sizeof(int)); // asigna y pone a cero un array de 4 int
    int* p2 = (int*)std::calloc(1, sizeof(int[4])); // igual, nombrando directamente el tipo de array
    int* p3 = (int*)std::calloc(4, sizeof *p3); // igual, sin repetir el nombre del tipo
    if (p2)
        for (int n = 0; n < 4; ++n) // imprime el array
            std::cout << "p2[" << n << "] == " << p2[n] << '\n';
    std::free(p1);
    std::free(p2);
    std::free(p3);
}

Salida: 

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

Véase también

Documentación de C para calloc