Does "ptr=malloc(sizeof(char)*10)" use many times,one after another allocate pointer to same memory block or cause memory leak?

Question

Suppose I have the following piece of code in my program:

char *ptr;
ptr=malloc(sizeof(char)*10);
ptr=malloc(sizeof(char)*10);
ptr=malloc(sizeof(char)*10);
ptr=malloc(sizeof(char)*10);

Will a pointer to the same memory block be assigned to ptr each time,or a separate piece of memory be reserved each time and its pointer assigned to ptr,resulting in memory leak each time malloc() is called?

I am still learning C so bear with me if it's too basic.I tried googling but found no answer.

EDIT::

Thanks for your answers.Please tell me if this approach of me deals with the memory leak risk.My program simply asks for names of 5 people and displays it,without using static arrays.After reading your answers,I put the free(ptr) inside the loop,else before I had planned to use it only once outside the loop,after the loop.Am I correct now?

#include <stdio.h>
#include<stdlib.h>
#include<string.h>

int main ()
{
char *names[5],*ptr;
int i;

for(i=0;i<=4;i++)
{
    ptr=malloc(sizeof(char)*10);
    printf("Enter name no.%d : \n",i+1);
    scanf("%s",ptr);
    names[i]=malloc(strlen(ptr)+1);
    strcpy(names[i],ptr);
    free(ptr);


}
for(i=0;i<=4;i++)
printf("%s\n",names[i]);

}

Answer 1

malloc() will never return the same memory block multiple times, unless (of course) it has been free()'d since the last time it was returned. This is guaranteed by the C standard. Therefore, your code also leaks memory. Any memory allocator that handed out the same piece of memory twice would be worse than useless: Applications would step on their own toes, using the same piece of memory for different purposes, likely concurrently.

Edit: Barring buffer overflow issues, your code is correct in that it frees the 10-char buffers referenced via ptr. Calling free(ptr) just once, outside the loop, would indeed be incorrect. However, your code (as shown here) does not free the memory allocated later in the loop body stored in names[i].

Answer 2

Yes, each malloc call will allocate a new block, which means that the previous one will be leaked.

EDIT: answer to the edited part of the question

You are now correctly releasing the blocks to which ptr points, however you are not releasing those allocated for names. You would also need:

for(i=0;i<=4;i++) {
   printf("%s\n",names[i]);
   free(names[i]);
}

In your case, you could skip using ptr and work on names directly. Here's an equally [un]safe version:

char *names[5];
int i;

for(i=0; i < 5; i++)
{
    names[i] = malloc(10);
    printf("Enter name no.%d : \n",i+1);
    scanf("%s",names[i]); // what if name is longer than 10 characters?
}

for(i=0; i < 5; i++)
{
   printf("%s\n",names[i]);
   free(names[i]);
}

However, operating system will reclaim the memory consumed by a process once the process exits, so in this simple example you don't have to worry, but I guess that this is only an illustration. I also assume that you don't care about user entering names longer than 10 characters which would write over the boundaries of allocated buffers.

Answer 3

A separate block of memory will be allocated each time, since C does not perform any garbage collection and no free calls are done in between the malloc calls. The first three blocks are leaked since you're not keeping pointers to them.

You can find out for yourself that the pointers are all distinct using a simple printf call:

for (int i = 0; i < 4; i++) {
    ptr = malloc(10);     // no need for sizeof(char), it's 1 by definition
    printf("%p\n", ptr);
}

This should print four distinct numbers.

Answer 4

This will cause a memory leak assuming each call is successful, all but the memory allocated to the last malloc will be inaccessible. You either need to keep a pointer to each block allocated by malloc or you need to free between successive calls. so yes, malloc will attempt to allocate distinct block of memory for each call. A quick test could be as follows:

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char *ptr;
    ptr=malloc(sizeof(char)*10);
    printf("%p\n", ptr);
    ptr=malloc(sizeof(char)*10);
    printf("%p\n", ptr);
    ptr=malloc(sizeof(char)*10);
    printf("%p\n", ptr);
    ptr=malloc(sizeof(char)*10);
    printf("%p\n", ptr);
}

This will print out the address allocated each time. If you added a free between each call to malloc you may end up with the same pointer, a quick test demonstrated this behavior.

Answer 5

Your second part is right: it's a memory leak.

Answer 6

A new block of memory is allocated each time you call malloc. This will create a memory leak as you have no way to reference the first three allocations to free them.

Answer 7

You can check memory leaks by using valgrind,its very useful in detecting memory leaks.

valgrind ./progr