Defragmentation of dynamically allocated memory in C++

Why can't the heap manager defragment memory just like the garbage collector of java does during garbage collection by moving around objects? If the memory in the C++ heap is fragmented it could be possible that the new requests to allocate memory may fail even though the total free space is available but it is not available as a contiguous chunk.

In Java the garbage collector can move blocks around to defragment the heap because it knows about all the references to all the blocks on the heap. When a block is moved during defragmentation the actual memory address is updated but all the managed references are also updated. This is not possible in C++ where an actual address is returned when a block is allocated on the heap. The C++ program can dereference any pointer that points into the block and these pointers can be computed by pointer arithmetic. If the block moves the pointers stored by the application code becomes invalid.

Can't the pointers be updated in C++ just like the Garbage collector updates the references?

@bourne: But how? These pointers are in other memory locations or registers and the C++ runtime doesn't know about all these pointers. In theory you could perhaps write a virtual machine and a C++ compiler that allowed pointers to be updated in the same way as it is done in the Java virtual machine but then you would also have the overhead of that environment and it would be silly to not switch to a fully garbage collected environment. I.e. use Java as your language.

There is no entity in C++ keeping track of where are the variables containing pointers, nor there is a garbage collector. Memory in C++ must be managed carefully. You could defragmentate memory if you code a memory manager yourself, but that would add CPU cost to your application, and thats exactly what coding in C++ is all about to avoid.