realloc

I have a function that will add a new position to an array by reallocating new memory every time it is called. The problem is that, for each call I need it to add one position to the array, starting from 1 at first call, but I understand that I have to mallocate before reallocating. So my question is, can I initially do something like p = malloc(0) and then reallocate for example using p = (int *)realloc(p,sizeof(int)) inside my function? p is declared as int *p . Maybe with a different syntax? Of course I could make a condition in my function that would mallocate if memory hasn't been

I encountered this small piece of code in this question , & wanted to know, Can the realloc() function ever move a memory block to another location, when the memory space pointed to is shrinked? int * a = malloc( 10*sizeof(int) ); int * b = realloc( a, 5*sizeof(int) ); If possible, under what conditions, can I expect b to have an address different from that in a ? It's possible for realloc to move memory on any call. True in many implementations a shrink would just result in the change of the reserved size in the heap and wouldn't move memory. However in a heap which optimized for low

I was reading Richard Reese's new (May 2013) O'Reilly book "Understanding and Using C Pointers", and I have a question about some code therein, on page 87. if (++length > maximumLength) { char *newBuffer = realloc (buffer, maximumLength += sizeIncrement); if (newBuffer == NULL) { free (buffer); return NULL; } currentPosition = newBuffer + (currentPosition - buffer); buffer = newBuffer; } I hope the names of the variables are self-explanatory; if context is needed, I will edit to provide the entire chunk of code and not just this excerpt. My question is about the line currentPosition =

how does realloc know the size of original data? void *realloc(void *ptr, size_t size); So, if the implementation is like this: temp = malloc(size); memcpy(.. // How much to copy? free(ptr); return temp; I realize this is not the original implementation, and realloc doesn't always do free, but when it does, how much does it copy? Edit: Thanks for the answers. But how can I then implement realloc in my code with malloc/free/..? It knows because malloc recorded that information when you called it. After all, the system has to keep track of the sizes of allocated blocks anyway so that it doesn't

How does one malloc an array of structs correctly if each struct contains an array of strings which vary in size? So each struct might have a different size and would make it impossible to realloc(numberOfStructs * sizeof(structName)) after malloc(initialSize * sizeof(structName) How does one allocate memory for this and keep track of what is going on? I am making some guesses here, based on the information you have provided. The only reason I can see for wanting to realloc an array of structs is if you want to add more structs to that array. That's cool. There are plenty of reasons to want