Función calloc() en la biblioteca C con programa EJEMPLO

¿Qué es calloc en C?

La función `calloc()` en C se utiliza para asignar múltiples bloques de memoria del mismo tamaño. Es una función de asignación dinámica de memoria que asigna espacio de memoria a estructuras de datos complejas, como arreglos y estructuras, y devuelve un puntero `void` a la memoria. `calloc` significa asignación contigua.

función malloc se usa para asignar un solo bloque de espacio de memoria, mientras que la función calloc en C se usa para asignar múltiples bloques de espacio de memoria. Cada bloque asignado por el calloc en la programación C es del mismo tamaño.

¿Por qué usar calloc() en C?

Las variables ordinarias y los arreglos de tamaño fijo bloquean sus dimensiones al compilar el programa, lo que desperdicia espacio cuando se necesitan menos elementos y provoca un fallo total cuando se requieren más. La función calloc() elimina esta limitación reservando memoria en tiempo de ejecución y, a diferencia de malloc(), borra cada byte antes de devolver el bloque. Esto convierte a calloc() en la opción ideal siempre que un programa necesite una región de memoria limpia y predecible para un arreglo o estructura cuyo tamaño solo se conoce mientras se ejecuta el código.

La asignación dinámica con calloc() se adapta a varias situaciones comunes:

• Matrices numéricas que deben comenzar en cero, como contadores, histogramas o acumuladores en ejecución.
• Estructuras de datos donde los valores basura restantes causarían problemas sutiles y difíciles de detectar.tracy bichos.
• Buffers cuya longitud depende de la entrada del usuario o de un archivo leído mientras se ejecuta el programa.
• Los bloques son demasiado grandes para la pila limitada, ya que calloc() accede a la memoria dinámica, que es mucho más grande.

Dado que el bloque reservado es contiguo y ya está inicializado a cero, puede tratarse inmediatamente como una matriz lista para usar sin necesidad de un bucle de inicialización independiente.

calloc() Sintaxis:

ptr = (cast_type *) calloc (n, size);

• El ejemplo anterior de calloc en C se utiliza para asignar n bloques de memoria del mismo tamaño.
• Una vez asignado el espacio de memoria, todos los bytes se inicializan a cero.
• El puntero que se encuentra actualmente en el primer byte del espacio de memoria asignado.

Siempre que hay un error al asignar espacio de memoria, como escasez de memoria, se devuelve un puntero nulo como se muestra en el siguiente ejemplo de calloc.

Cómo usar calloc

El siguiente programa calloc en C calcula la suma de una secuencia aritmética.

#include <stdio.h>
    int main() {
        int i, * ptr, sum = 0;
        ptr = calloc(10, sizeof(int));
        if (ptr == NULL) {
            printf("Error! memory not allocated.");
            exit(0);
        }
        printf("Building and calculating the sequence sum of the first 10 terms \ n ");
        for (i = 0; i < 10; ++i) { * (ptr + i) = i;
            sum += * (ptr + i);
        }
        printf("Sum = %d", sum);
        free(ptr);
        return 0;
    }

Resultado del calloc en el ejemplo de C:

 
Building and calculating the sequence sum of the first 10 terms
Sum = 45

Diferencia entre calloc() y malloc()

Tanto calloc() como malloc() reservan memoria en el montón y ambos devuelven un puntero vacío, o NULL en caso de error, pero difieren en tres aspectos prácticos que determinan cuál utilizar.

• Inicialización: calloc() establece cada byte en el nuevo bloque a cero, mientras que malloc() deja el contenido sin inicializar, por lo que un bloque malloc() contiene basura impredecible hasta que el programa escribe en él.
• Argumentos: calloc() toma dos argumentos, el número de elementos y el tamaño de cada uno, escrito calloc(n, size); malloc() toma un solo argumento, el número total de bytes, escrito malloc(n * size).
• Velocidad: malloc() es ligeramente más rápido porque omite el paso de inicialización a cero, razón por la cual el código que sobrescribe la memoria inmediatamente a menudo lo prefiere.

Ambas funciones están declaradas en stdlib.h y ambas liberan su memoria con la misma función free(). Elija calloc() cuando sea importante un bloque limpio y con memoria inicializada a cero, y malloc() cuando se prefiera la máxima velocidad y el programa gestione la inicialización por sí mismo.

Cómo liberar la memoria asignada por calloc()

La memoria reservada por `calloc()` reside en el montón y nunca se libera automáticamente. Cuando un programa asigna memoria continuamente sin liberarla, consume gradualmente toda la memoria disponible, un problema conocido como fuga de memoria. La función `free()` devuelve un bloque terminado al sistema para que el espacio pueda ser reutilizado por asignaciones posteriores.

La función free() toma un único argumento, el puntero que devolvió calloc(), y libera todo el bloque de una vez:

int *ptr;
ptr = calloc(10, sizeof(int));
if (ptr != NULL) {
    /* use the allocated memory here */
    free(ptr);   /* release the block */
    ptr = NULL;  /* avoid a dangling pointer */
}

Siga estas reglas para gestionar la memoria de calloc() de forma segura:

• Llama a free() exactamente una vez por cada llamada a calloc() exitosa; liberar el mismo bloque dos veces provoca un comportamiento indefinido.
• Tras liberar el puntero, este debe establecerse en NULL para que no pueda reutilizarse como un puntero colgante.
• Nunca libere con free() un puntero que calloc() no haya devuelto, incluyendo uno desplazado por aritmética de punteros.
• Asegúrese de que cada asignación coincida con una liberación antes de que el puntero quede fuera del ámbito.

Dado que tanto calloc() como malloc() acceden al mismo montón, la disciplina de liberación es idéntica para ambas funciones: un free() por cada asignación exitosa y ningún acceso al bloque posteriormente.ping La asignación y liberación equilibrada de memoria es la práctica fundamental de la gestión manual de memoria en C, y previene tanto las fugas de memoria como los fallos causados ​​por la reutilización de memoria que ya ha sido liberada.

Preguntas Frecuentes