Realloc equivalent in C++

Question

Yes, another realloc vs. std::vector question. I know what you\'re going to say, and I agree, forget manual memory allocation, and just use a

Answer 1

You should avoid realloc completely anyway, because you can't move around C++ objects like that.

• Use buf = new unsigned char[sizeof(T) * capacity] to create a new buffer
• Cast the allocated unsigned char * to T * and use these T-pointers from now on
• Construct new elements via "placement new", as in new (&buf[i]) T(original_copy)
• To copy the buffer to a larger buffer, allocate the new one first, use std::uninitialized_copy (not std::copy), then destroy the elements in the old one using buf[i].~T() and deallocate the old buffer using delete [] buf.

All of this is assuming you don't have to worry about exception-safety, which is probably OK for the assignment.
Just be aware that in real-world code you'd have to guarantee exception safety and it's a lot more tedious than this.

Answer 2

The problem with realloc is that is may move the existing data to a different range of contiguous addresses. Should it need to do so, given it's a C function the data is copied without any nod to C++ object lifetime:

• copy/move constructors aren't used
• destructors aren't invoked afterwards for the source objects

This can cause fatal consequences - for example, when the objects being moved contain pointers/references that remain pointing at addresses in the memory area being vacated.

Sadly, normal malloc implementations don't allow a callback hook allowing you to replace the memory-content-copying code with your own C++-safe implementation. If you're determined you could try to find a more flexible "malloc" library, but it's unlikely to be worth the hassle and risk.

Consequently, in the general case you should use new to change your capacity, copy/move each object, and delete the originals afterwards.

If you're certain your data is simple enough that a memcpy-style relocation won't cause adverse consequences, then you can use realloc (at your own risk).