重新分配会更改指针地址吗？

Question

Take this code for example:

Struct* allocSomething(void) {
    int n; 
    Struct *something = malloc(n*sizeof(Struct));
    return something;
}

Struct* reallocSomething(Struct **s) {
    int n;
    Struct *something = realloc(*s, (n*sizeof(int)) - 1 * sizeof(Struct));
    return something;
}

int main() {
    Struct *point = allocSomething();
    //code does something...
    point = reallocSomething();
    free(point);
}

My question is, after calling reallocSomething , point has still the same address returned by allocSomething ? For example, if point have address 0x01 , when this pointer get reallocated by reallocSomething , is that address still 0x01 ?

Answer 1

From the man page for realloc :

 void *realloc(void *ptr, size_t size); 

....

realloc() returns a pointer to the newly allocated memory, which is suitably aligned for any kind of variable and may be different from ptr , or NULL if the request fails. If size was equal to 0, either NULL or a pointer suitable to be passed to free() is returned. If realloc() fails the original block is left untouched; it is not freed or moved.

Since realloc may move the allocated memory to a new location, you need to account for this.

Answer 2

Don't count on it staying at the same address. The system is allowed to move the whole affair to a different address for whatever reason. While the chunk of memory you're requesting is smaller, and it should logically fit in space vacated by the previous allocation, this is not an atomic operation and any interruption or timesharing can have something else grab that memory space. There's probably other shenanigians with whatever system you're using, but standard-wise? Don't expect the address to remain the same. And don't expect it change either.

Answer 3

From the point of view of the Standard, unless realloc fails, the act of calling it will destroy not just the storage identified by the old pointer, but also the old pointer itself. A compiler may behave in arbitrary and capricious fashion if code tries to access the old pointer other than by examining the bytes thereof, even if the bit pattern in that pointer happen to precisely match those of the new pointer.

Quality implementations may (and probably should) allow programs to use realloc in some ways beyond those required by the Standard (eg check whether an object has moved, and recompute pointers that identify portions thereof if it has, but don't bother which such computation if it hasn't moved) but the Standard defines no means via which indications can indicate whether or not they support such constructs.