dynamic memory allocation (C Programming)

Question

I am learning about dynamic memory allocation and having a problem while doing the exercise. I would like to allocate the memory for p. The following is the codes.

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

int main(void)
{
    int *p, i;

    p = (int *)malloc(7 * sizeof(int));
    if (p == NULL)
    {
        printf("Memory Allocation Errors\n");
        exit(1);
    }
    for(i=0; i<6; i++)
    {
        p++;
        *p = i;
        printf("%3d",*p);
    }
    printf("\n");
    p = p - 6;
    free(p); 
    p = NULL;
    return 0;
}

The running result is:0 1 2 3 4 5

However, when I change the code

p = (int *)malloc(7 * sizeof(int));

to this

p = (int *)malloc(6 * sizeof(int));

the running result would be

0  1  2  3  4  5
Error in `./memo2': free(): invalid next size (fast): 0x0000000001bc5010 ***
Aborted (core dumped)

I think for this code, p only need the memory of the size of 6 integers, could anyone give a explanation?

Another question is that why should p++ be ahead of *p = i? If I make *p = i before p++, the running result would be 0 0 0 0 0 0.

First of all, don't cast the result of malloc. Secondly of all, you don't initialize the first item in the allocated memory. Thirdly, wouldn't it be much easier to either use array-indexing syntax instead of pointer arithmetic, or to have two pointers, one original that you pass to free and one that you do whatever arithmetic you want? — Some programmer dude
– Some programmer dude, Commented Aug 4, 2014 at 10:35
Use printf("\n p[%p]", p); after allocation and before free and check it — mahendiran.b
– mahendiran.b, Commented Aug 4, 2014 at 10:41
You wasted one slot 'p' itself. 'p' is incremented before first using. So this is a one-off error. — Danke Xie
– Danke Xie, Commented Aug 4, 2014 at 11:10

sclarke81 · Accepted Answer · 2014-08-04 11:05:24Z

First question - you get an error when you malloc memory for 6 integers because in your for loop you increment the pointer before assigning a value. Therefore you leave the first address you allocated empty. If you assign a value and then increment the pointer this will solve your problem.

Second question - if you perform the printf after incrementing the pointer you won't print the value you just set. You need to assign the value, print it, then increment the pointer.

Here's your code with those changes:

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

int main(void)
{
   int *p, i;

   p = (int *)malloc(6 * sizeof(int));
   if (p == NULL)
   {
      printf("Memory Allocation Errors\n");
      exit(1);
   }
   for(i=0; i<6; i++)
   {
      *p = i;
      printf("%3d",*p);
      p++; 
   }
   printf("\n");
   p = p - 6;
   free(p); 
   p = NULL;
   return 0;
}

However, I would recommend you use array indexing syntax. As well as being easier to read, this means that you don't actually change the p meaning that when you free the memory it will be on the correct address. Here's an updated version of your code using array indexing:

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

int main(void)
{
   int *p, i;

   p = (int *)malloc(6 * sizeof(int));
   if (p == NULL)
   {
      printf("Memory Allocation Errors\n");
      exit(1);
   }
   for(i=0; i<6; i++)
   {
      p[i] = i;
      printf("%3d",p[i]);
   }
   printf("\n");
   free(p); 
   p = NULL;
   return 0;
}

DarkDust · Accepted Answer · 2014-08-04 11:45:52Z

Your code needs 7 "slots" to store 6 numbers because the very first slot is immediately skipped:

for(i=0; i<6; i++)
{
    p++; // <-- Skip to next "slot"
    *p = i;
    printf("%3d",*p);
}

So the first slot is never used since it's immediately skipped. To fix this, first work with the current pointer, then increment it:

p = malloc(6 * sizeof(int));
if (p == NULL)
{
   printf("Memory Allocation Errors\n");
   exit(1);
}
for(i=0; i<6; i++)
{
    *p = i;
    printf("%3d",*p);
    p++; // <-- Skip to next "slot"
}

Also, the pointer you pass to free must be exactly the same pointer you got from malloc. You can calculate the original value by undoing the additions you did in a loop, but it's easier to store the original value (less chance to screw up):

int *p, *orig_p, i;

orig_p = malloc(6 * sizeof(int));
if (orig_p == NULL)
{
   printf("Memory Allocation Errors\n");
   exit(1);
}
p = orig_p;
...
free(orig_p);

mahendiran.b · Accepted Answer · 2014-08-04 10:46:17Z

1

For your subquestion2, find the answer in below

for(i=0; i<6; i++)
{
    *p = i;
    printf("%3d",*p); //Fix1
    p++; //Fix2
}

ie,you should print the value *p before increment the pointer p.

answered Aug 4, 2014 at 10:46

mahendiran.b

1,3431 gold badge8 silver badges14 bronze badges

Comments

Sathish · Accepted Answer · 2014-08-04 11:55:46Z

1

1) When you do like this

for(i=0; i<6; i++)
{
  p++; // here before assigning the value you are incrementing address of p(first location is waste)
  *p = i;
  printf("%3d",*p);
}

So it does not store value in first memory location(this location is wasted). it stores value from second location on wards. so it requires 7 location for 6 numbers.

2) If you make *p = i before p++, like below code-

for(i=0; i<6; i++) 
{
    *p = i; // you are assigning the value.
    p++; // here you are incrementing the value
    printf("%3d",*p); // it will print the value at the incremented loaction
}

For example- Consider starting address is 1000. when you do *p = i; i is assigned to 1000, p++; will increment the location to 1004. After incrementing the address you are printing the value. It may give you 0 or garbage values. because printf("%3d",*p); will print the value at 1004. you don't know what value is there. So avoid this types of method.

Try the following code-

p = (int *)malloc(6 * sizeof(int)); // Fix 1
if (p == NULL)
{
    printf("Memory Allocation Errors\n");
    exit(1);
}
for(i=0; i<6; i++)
{
    *p = i;
    printf("%3d",*p);
    p++; // Fix 2
}
printf("\n");
p = p - 6;
free(p); 
p = NULL;

edited Aug 4, 2014 at 11:55

answered Aug 4, 2014 at 11:19

Sathish

3,8681 gold badge20 silver badges28 bronze badges

1 Comment

Jinlong Over a year ago

Others are right except p = p -6 rather than p = p -24, pls check that.

ani627 · Accepted Answer · 2014-08-04 12:43:34Z

1

Try this.

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

int main(void)
{
 int *p, i;

 p = malloc(7 * sizeof(int)); /* Memory allocated for 7 intergers */
 if (p == NULL)
 {
  printf("Memory Allocation Errors\n");
  exit(1);
 }
 for(i=0; i<=6; i++) /* Assign values */
 {
  // This is a better way of assignment, easy to understand
  // *(p+i) = i OR p[i] = i
  p[i] = i; 
  printf("%3d",p[i]); 
 }
 printf("\n");
 // p = p - 6; /* Not required */ 
 free(p); /* Free the pointer */
 // p = NULL; /* Not required */
 return 0;
}

The output will be:

0 1 2 3 4 5 6

edited Aug 4, 2014 at 12:43

answered Aug 4, 2014 at 11:21

ani627

6,0958 gold badges42 silver badges48 bronze badges

3 Comments

DarkDust Over a year ago

Your solution is correct, but you should explain what you changed and why. Without such an explanation, the OP has to figure what you changed and guess why you did it (which might be impossible for a newbie).

ani627 Over a year ago

Thanks for suggestion DarkDust, I have added more comments.

DarkDust Over a year ago

Could still use a bit more explanation (the main point I'd like to have seen explained is that array syntax avoids some of the problems the OP had), but still +1 for the effort ;-)

David Schwartz · Accepted Answer · 2014-08-04 10:36:10Z

0

You have p, that's one slot. Then you increment p six times, that's six more slots. So you need seven slots in total.

answered Aug 4, 2014 at 10:36

David Schwartz

184k18 gold badges229 silver badges293 bronze badges

Collectives™ on Stack Overflow

dynamic memory allocation (C Programming)

6 Answers 6

Comments

Comments

Comments

1 Comment

3 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

Comments

Comments

Comments

1 Comment

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related