malloc和calloc

Question

I know this question may be marked as a duplicate of difference between malloc and calloc but still i would like to ask it.

i know calloc initilizes the memory block,here my question is not focusussing on that part.

my question is

the definition of malloc says it allocates a block of memory of specified size.

and calloc says it allocates multiple block of memory ,each of the same size.

is this allocation of one block of memory and multiple blocks of memory is a real difference between the two?

because i feel we can do the same using malloc which can be done by calloc.

for example :

int *ptr;
ptr=(int *) malloc(100 * (sizeof(int)));

and

int *ptr;
ptr=(int *) calloc(100,sizeof(int));

would end up allocating 100 times the memory required by the int.

Answer 1

calloc fills the memory with ZERO's.

p=calloc(n, m); 

is equivalent to

p=malloc(n*m); 
memset(p, 0, m * n);

Thus, if you intend to set your allocated memory to zero, then using malloc you have to compute n*m twice, or use a temp variable, which is what calloc does.

Edit: I've just read the ISO C standard and found that nowhere is specified that the implementation of calloc should check if n*m overflows, that is, if it exceeds the constant SIZE_MAX in the C99 standard.

Answer 2

You are correct with your code examples ... the actual memory that is being pointed to by ptr is going to be the same size (ie, and array on the heap of 100 int objects). As others have mentioned though, the call to calloc will actually zero-out that memory, where-as malloc will simply give you a pointer to that memory, and the memory may or may not have all zeroes in it. For instance, if you get memory that had been recycled from another object, then the call to malloc will still have the values from its previous use. Thus if you treat the memory as if it was "clean", and don't initialize it with some default values, you're going to end up with some type of unexpected behavior in your program.

Answer 3

与malloc不同， calloc还初始化内存块以包含零。

Answer 4

Yes the main difference is mentioned above. Also calloc() is slower than malloc() from operating system memory allocation perspective.

The malloc() returns pointer doesn't touch the real memory until the program touches malloc(). Whereas calloc() back's the memory with RAM.

Answer 5

This has been mentioned previously on this site, but judging from the other answers, I think it is worth repeating; multiplying two integers may result in overflow, and if that happens,

ptr = malloc(num*size);

will probably not have the desired result (and most likely result in a later segmentation fault). For these situations, calloc(num,size) should be preferred (though you could also test for overflow before calling malloc, if the fact that calloc() initializes the newly allocated memory to zero bothers you).

Answer 6

the main difference between the two is calloc initializes the memory blocks to zero while malloc created memory blocks contains garbage value.

so it is more suitable to use calloc instead of malloc to avoid uncertainity in your code.

Answer 7

===You can see the following difference for mallac() and calloc() function===

Initialization:
malloc() doesn't clear and initialize the allocated memory.
calloc() initialize the allocated memory by zero.

Syntex:

void *malloc(size_t size);                   // syntex for malloc() function
void *calloc(size_t num, size_t size);       // syntex for calloc() function

// example
ptr = malloc(num*size);   // for malloc() function
ptr = calloc(num,size);   // for calloc() function

Argument:
If you consider malloc() syntax, it will take only 1 argument.
If you consider calloc() syntax, it will take 2 arguments.

Manner of memory Allocation::
malloc() function assigns memory of the desired 'size' from the available heap.
calloc() function assigns memory that is the size of what's equal to 'num *size'.