special mode for no free() on delete's? C++

I know this will sound weird but i need my app to run fast and it does a lot of new and delete. All function calls new and passes the ptr back expect for the ones pushing a pointer to a list or deque.

At the end of the main loop the program goes across all of that memory and deletes it (unless i forgot to delete it). I am not exaggerating. Is there a mode that allows my code to allocate objs for new but doesnt delete them开发者_运维技巧 on delete but just mark it as unused so the next new for that struct will use it instead of doing a full allocation?

I imagine that would boost performance. It isnt fully done so i cant benchmark but i am sure i'd see a boost and if this was automatic then great. Is there such a mode or flag i can use?

I am using gcc (linux, win) and MSVC2010(win).

Try object pooling via Boost - http://www.boost.org/doc/libs/1_44_0/libs/pool/doc/index.html

What do you mean by "end of the main loop" - after the loop finishes, or just before it repeats?

If the former, then you can safely leave memory allocated when your process exits, although it isn't recommended. The OS will recover it, probably faster than you'd do by deleting each object. Destructors won't be called (so if they do anything important other than freeing resources associated with the process, then don't do this). Debugging tools will tell you that you have memory leaks, which isn't very satisfactory, but it works on the OSes you name.

If the latter, then "marking the memory unused so that the next new will use it" is exactly what delete does (well, after destructors). Some special-purpose memory allocators are faster than general-purpose allocators, though. You could try using a memory pool allocator instead of the default new/delete, if you have a lot of objects of the same size.

"I imagine that would boost performance"

Unfortunately we can't get performance boosts just by imagining them ;-p Write the code first, measure performance, then worry about changing your allocation once you know what you're up against. "Faster" is pretty much useless if the boring, simple version of your code is already "easily fast enough". You can usually change your allocation mechanism without significant changes to the rest of your code, so you don't have to worry about it in up-front design.

What your are describing is what malloc and co usually do, keeping memory around and reallocating it for similar sized allocations.

i believe what you are looking for is a "placement new". Use new to allocate byte size memory only once. And later on just use the ptr as follows

Type* ptr = static_cast<Type*>(operator new (sizeof(Type))); // need to call only once and store the pointer
Type* next_ptr = new (ptr) Type();

Manually call the destructors instead of delete.

next_ptr->~Type();

Since no memory allocation happens this should definitely be fast. "how fast" i am not sure

Using a memory pool is what you are looking to achieve.

You also could use a few of the windows Heap allocation methods, and instead of just free'ing each individual allocation, you could just free the entire heap all at once. Though if you are using a memory profiling tool (like bounds checker) it will think it's a problem.