Allocating again and again? HELP

[givmefive5]

int foodcalorie (int *num,struct recipe **foodcal)
{
     char ans='Y';
     system("cls");
     while(ans=='Y' && *foodcal!=NULL)    
      { 
        system("cls");
        if((*foodcal=malloc(sizeof(struct recipe)*(*num)))!=NULL){
         printf("Input name of food\n");
         scanf(" %s",(*foodcal+(*num))->name);
         printf("Input calorie count\n");
         scanf(" %d",&(*foodcal+(*num))->calorie);
         printf("Input specific amount with unit\n");
         scanf(" %f %s",&(*foodcal+(*num))->quantity,(*foodcal+(*num))->unit);    
         printf("Do you wish to add again?  [Y]es or [N]o\n");
         scanf(" %c",&ans);
         if(ans=='Y')
         *num+=1;
         }
      } 
        
         return 1;
     
}

I would just like to ask, is it possible to allocate to the same variable
again after incrementing the multiplier for "malloc"? "realloc" also can't work >_< Checked where the error was and it was after looping once then gives me the "Access Violation Segmentation Fault. Thank you very much

[laserlight]

I would just like to ask, is it possible to allocate to the same variable
again after incrementing the multiplier for "malloc"? "realloc" also can't work

realloc would be a correct approach, though you should assign the result to another pointer first, then if that pointer is not a null pointer, assign it to the original pointer.

In your case, you are using a pointer to a pointer because you want to change the pointer from the caller and have it reflected in the caller. Although messing around with the extra level of indirection can work, one approach is to simplify with the help of another pointer, e.g.,

struct recipe *temp_foodcal;
if ((temp_foodcal = realloc(*foodcal, sizeof(*temp_foodcal) * *num)) != NULL) {
    /* ... */
    printf("Input calorie count\n");
    scanf(" %d", &temp_foodcal[*num].calorie);
    /* ... */
    *foodcal = temp_foodcal;
}

Notice that I used array notation. It will make your life easier.

Incidentally, you are expanding the dynamic array on each iteration. This is slow. A better approach is to keep track of the dynamic array's size (number of elements in use) and capacity (number of numbers for which space is allocated), then expand by some factor greater than 1 when size is about to exceed capacity.