c++ realloc same pointer warranty

Question

Using the std::realloc function:

If the new size is smaller, does it always have warranty to keep the memory block on the same position and only make it smaller, or it can move sometimes the whole block?

The reason to ask this, is that we'are writing a large and very hard code, and it is useful to make read only all the variables we need to leave unchanged, to obtain compiler's errors, when we try to change the wrong variable.

#include<cstdlib>
#include<iostream>
using namespace std;

int main(){
  //From 10,000,000 unsigned ints to 10 unsigned ints
  unsigned int * const array=new unsigned int[10000000];
  cout<<array<<endl;
  realloc(array,10*sizeof(unsigned int));
  cout<<array<<endl;
  delete array;
  return 0;
}

Answer 1

No!! If realloc succeeds, the old pointer (unless it was a nullpointer) is indeterminate.

Also, do not mix incompatible memory-management-functions (assume incompatibility unless guaranteed otherwise).

realloc only has the guarantees explicitly given in the standard:

• If return-value is non-0: New pointer points to of at least size byte, the first min(oldsize, newsize) being equal to the passed block.
• Else if size is non-0, nothing happened to the passed block.
• Else the old block may have been deallocated, or not.

Moral: Never pass a 0 size to realloc, and only use the old pointer for anything (including comparison to the new pointer), if realloc failed (or you passed a nullpointer).

7.22.3.5 The realloc function

#include <stdlib.h>
void *realloc(void *ptr, size_t size);

2 The realloc function deallocates the old object pointed to by ptr and returns a pointer to a new object that has the size specified by size. The contents of the new object shall be the same as that of the old object prior to deallocation, up to the lesser of the new and old sizes. Any bytes in the new object beyond the size of the old object have indeterminate values.
3 If ptr is a null pointer, the realloc function behaves like the malloc function for the specified size. Otherwise, if ptr does not match a pointer earlier returned by a memory management function, or if the space has been deallocated by a call to the free or realloc function, the behavior is undefined. If memory for the new object cannot be allocated, the old object is not deallocated and its value is unchanged.

Returns
4 The realloc function returns a pointer to the new object (which may have the same value as a pointer to the old object), or a null pointer if the new object could not be allocated.

Answer 2

Although I agree with the other answers in that you should not depend on it, there is an answer to be found in the glibc source. (I am assuming that you are using glibc, as you have not (yet) answered my comment asking which C library you are using)

EDIT: Using realloc on memory allocated by new is indeed disallowed, as other answers have mentioned.

Memory allocated without internally using mmap

If a block of memory is not allocated with mmap, __libc_realloc calls the _int_realloc function, which contains the following snippet of code:

if ((unsigned long) (oldsize) >= (unsigned long) (nb))
 {
   /* already big enough; split below */
   newp = oldp;
   newsize = oldsize;
 }

This makes the pointer to the new memory equal the pointer to the old memory and sets the size accordingly. Note the split below comment; the old memory block may be resized to the requested size, but is not moved.

---

Memory allocated internally using mmap

If the memory was internally allocated using mmap, there are two ways of resizing the memory area; mremap_chunk or a series of calls to malloc, memcpy and free. If the mremap_chunk function is available, it is used instead of the latter option.

Memory reallocated using mremap_chunk

The function mremap_chunk contains this snippet of code

/* No need to remap if the number of pages does not change.  */
if (size + offset == new_size)
    return p;

If the number of pages does not change from the old size to the new size, there is no need to remap and the old pointer is returned.

Memory reallocated using malloc, memcpy and free

If mremap_chunk is not available, the __libc_realloc source continues with the following:

/* Note the extra SIZE_SZ overhead. */
if (oldsize - SIZE_SZ >= nb)
    return oldmem;                         /* do nothing */

If the oldsize variable minus the chunk size is more than or equal to the new size, just return the old memory.

---

Well then, here we are. In all cases, glibc returns a pointer to the old memory, not moving it (but possibly resizing it). If you are using glibc (and can somehow guarantee that the only C library you are using it with is glibc, and can guarantee that it won't change at some point in the future), you are able to rely on the behavior that realloc does not move a block of memory if the requested size is equal to or less than the old size.

Answer 3

C99 draft 7.20.3.4 says:

[#4] The realloc function returns a pointer to the new object (which may have the same value as a pointer to the old object), or a null pointer if the new object could not be allocated.

You should not assume it.

And also: don't mix new and realloc as πάντα already wrote in the comments.

Answer 4

Nothing's guaranteed about realloc. It might shrink the block in place, or it might allocate a new one and copy the data. It might also fail.

An important point: realloc is only for reallocating memory that was previously allocated by malloc. In your code above, you are using new which has no equivalent for reallocation.

Also realloc actually returns the address of the new memory block, so in your code above you will be a) leaking this and b) referencing/freeing potentially already de-allocated memory.