Diferencia en el diseño del bloque de memoria asignado por malloc y calloc?

Question

calloc asigna num bloques de memoria, cada uno de tamaño size:

void * calloc (size_t num, size_t size);

asignar espacio para matriz en la memoria asigna un bloque de memoria para una matriz de elementos num, cada uno de ellos tamaño bytes de longitud e inicializa todos sus bits a cero.

En contraste, malloc asigna un bloque de memoria de tamaño size:

void * malloc (size_t size);

Asignar bloque de memoria asigna un bloque de bytes de tamaño de memoria, devolviendo un puntero a la comienzo del bloque.

---

¿Hay alguna diferencia entre ambos (a excepción del cero inicialización por calloc)?

¿Qué significa calloc exactamente por num bloques de memoria como en la práctica la región de memoria devuelta es contigua también.

Creo que tiene que haber alguna diferencia, de lo contrario no tendría mucho sentido definir dos interfaces diferentes para estos métodos.

Answer 1

En la práctica, hacen lo mismo. La ventaja de calloc es que las buenas implementaciones realizarán una detección de desbordamiento al realizar la multiplicación necesaria para determinar la cantidad de memoria que necesita.

Si lo haces algo como esto:

void * 
calloc(size_t nmemb, size_t size) 
{ 
    size_t sz = nmemb * size; 
    void *res = malloc(sz); 

'SZ' no podría llegar a ser lo que usted espera que sea. Malloc asignará mucho menos de lo que se esperaba, pero la persona que llama puede terminar tratando el área devuelta lo suficientemente grande. Esto lleva a desbordamientos de pila con todas las implicaciones de seguridad que generalmente tiene.

Answer 2

La única diferencia real es la inicialización 0 con calloc().

¿Por qué calloc() funciona con tamaño de bloque y conteo de bloques mientras que malloc() no, nunca ha sido claro para mí.

Answer 3

sentimos, no hay diferencias (pero la memoria se pone a cero)

calloc() puede ser útil cuando se usa con las matrices, en las que tiene dos valores diferentes en la mano: el tamaño de las matrices y la dimensión de una sola célula . La memoria del área devuelta es contigua en ambos casos, y probablemente utilicen las mismas estructuras de datos para realizar un seguimiento de dicha área (pero esto depende de la implementación)

Answer 4

Ambos son exactamente iguales. Calloc quiere que especifique cuántos bloques de un tamaño dado desea asignar, porque los inicializa con 0. La estructura subyacente es exactamente la misma.

Answer 5

que se pueda imaginar calloc() por ser más o menos:

void* calloc(size_t nmemb, size_t size) 
{ 
    const size_t nbytes = nmemb * size; 
    void *p = malloc(nbytes); 
    if(p != NULL) 
    memset(p, 0, nbytes); 
    return p; 
} 

Tenga en cuenta que podría ser implementado de forma completamente diferente, pero es el equivalente funcional de los anteriores. No hay diferencia en el "diseño interno" de la memoria, obtienes un bloque contiguo.

Answer 6

he tratado de averiguar cómo funciona calloc

i encontrar a continuación código

/* We use this function occasionally since the real implementation may 
    be optimized when it can assume the memory it returns already is 
    set to NUL. */ 
void * weak_function 
calloc (size_t nmemb, size_t size) 
{ 
    /* New memory from the trivial malloc above is always already cleared. 
    (We make sure that's true in the rare occasion it might not be, 
    by clearing memory in free, below.) */ 
    size_t bytes = nmemb * size; 

#define HALF_SIZE_T (((size_t) 1) << (8 * sizeof (size_t)/2)) 
    if (__builtin_expect ((nmemb | size) >= HALF_SIZE_T, 0) 
     && size != 0 && bytes/size != nmemb) 
    return NULL; 

    return malloc (bytes); 
} 

Se puede ver que no hay gran diferencia entre calloc y malloc.

se puede brouse código de glibc en aquí

http://sourceware.org/git/?p=glibc.git;a=blob;f=elf/dl-minimal.c

Answer 7

Sí .¿Qué Calloc() hace es que asigna n bloquear cada uno de tamaño size_t size & entonces cada bloque de tamaño size_t size a cero.