Piko3D

Updates
7-01-2011 14:17
Changed and extended the information on possible heap corruptions

Introduction:

This tutorial can be helpfull for people trying to write their own array, or thinking about implementing a memory pool, and is meant for the advanced programmer. Piko3D uses it’s own array implementation which turned out to be about 25% faster than the std::vector (in optimized release, 500% faster in debug) and easier to use.

When writing your own array or memory pool, you might come to a point where you need to new an object into your own memory block. This in order to have C++ call the proper constructor or copy constructor and initialize your memory properly.

This is where overloading the new operator, or placement new, comes in handy.

The Code

The new() operator can be overloaded. In fact: Our friend the std::vector uses a placement new() operator to copy construct objects in a pre-allocated buffer.  You can use it by including <new> And it works like this:

1
2
3
4
5
6
7
8
//the missing variable after size_t means we don't actually use this parameter

//We only use buffer

void* operator new (size_t, void* buffer) {

    return buffer;

}



void operator delete(void*, void*) {

}

Yes.. that’s it… It doesn’t do anything. See here’s how operator new() works: It calls the operator and passes a size_t to specify how much memory is needed to allocate the object. Now all it asks is that you return a void* to a block of memory that’s big enough!

What we do here, is overload the new operator, so that it takes one more parameter: The void* to the buffer where we want to place our object. We can return it, so that C++ will place our object in our buffer!

Please note that we’ve also overloaded a delete operator. This delete operator is here, so the compiler knows what to call when our placement new fails. It does nothing, since the placement new doesn’t actually allocate any memory of its own.. But if you don’t specify this operator delete, you will get a compiler warning.

You use the placement new like this:

1
2
3
4
//We allocate enough space for 10 instances of Foo

Foo buffer* = (Foo*)malloc(sizeof(Foo) * 10);

//We construct a Foo object in our memory block.

new (&buffer[0])  Foo();

Notice that we pass the adress of the buffer’s first object, object[0], as the adress where we want our Foo to be placed! C++ will then use the space pointed to by the returned pointer to call the object constructor on.

IMPORTANT: BE CAREFUL WITH DELETES!!

You do NOT want to call delete on placement newed objects, unless the memory allocated is only used by a single constructed object, AND that object is constructed at the start of the block! In this case the ENTIRE block will be deleted. Not just the object. Calling delete in any other case will result in HEAP CORRUPTION! Since a block descriptor with extra information about the size of the block is stored when allocating a block of memory, deleting an object in the middle of the memory block will cause delete to look for the block descriptor in the wrong place! This will cause a memory block of undetermined size to be freed o_O…. MORE HEAP CORRUPTION!!

If you want to destruct an object that you have created with your placement new (unless it’s the only object in the block and it’s at the start of the block) you will HAVE TO call the destructor explicitly. This is about the only case where you’ll ever have to call the destructor explicitly… but here’s how that looks:

1
2
3
4
5
class Foo {};



void destroyElt(Foo& elt1) {

    elt1.Foo::~Foo();

}

Wrapping up…

To be complete, std also defines placement news for arrays (new []) . They work in exactly the same fashion. Using the <new> header is nice because it defines all the standard placement news and calling conventions for them. Plus they also implement the much needed matching delete operatators.

Ofcourse you can also define your own placement new. You could change the void* to whatever you would want to use in the new operator to allocate your memory. However when implementing a memory pool for instance, it may be that you’d also have to have an overwritten delete operator. The ones provided only work when new fails. You cannot overload the global delete! If you want to overload the delete for a class, you’d have to overload it as a class member.

If you go and overwrite the new and delete in a class, this overwrites the use of your placement new. If you still want to be able to use this object with placement news, you’d have to define your class new and a separate placement new for that class, in order for it to work in, let’s say, your array, or an std::vector for that matter.

Hope this helped! If you still have questions, remarks, tips, or want to know more details, just drop me a line, or leave a comment.