Thread: smart pointer+allocator?

Hi everyone,

Instead of smart pointers is it not usually better to use something like:

Code:

Object obj = pool.get(memory_size);
//std::cout.write(static_cast<const char*>(obj.front()),memory_size);

And then get at least [memory_size] free aligned memory? Object class will then work exactly as a smart pointer, but instead of deleting the memory it just push it back to the pool and therefore can it be reused again. A summarize is smart pointers together with allocators.

It sounds of course that it should be more efficient, but if it should, why are it used so rarely?

Thanks in advance.

The decision to use a special allocator (like a pool allocator) is separate from the decision to use a smart pointer. They solve different problems. You can use one or the other or both or neither with no problem.

The smart pointer governs ownership of a resource and helps determine when the memory it uses can be freed to be used again. The pool allocator is just used to determine where to get the memory from and helps reduce the number of actual calls to allocate and deallocate. If you use a pool allocator, you still need code to determine when to free the memory back into the pool, and that's what a smart pointer can help you with.

Well, I know that, but I have never seen anyone use smart pointers together with allocators of any kind, even if I am not I a programming freak who have it neither as a job or doing it many hours per day. I have read pretty much lines of code in my life comparing to my age but never have them been used together. Can it be so that it is maybe much better to use a optimized malloc function as goggle's tcmalloc instead of smart pointers+allocators, less overhead (the allocator most support thread safety)? But of course, it should probably much less error prone and better to just overload global new/delete and pass it to the memorypool then, why have I not thought about if before now

I think you may be right. If you're going to use the special allocator, in most cases you might as well do it for your entire program (or module) rather than do it just for some smart pointers.

I have had to use a pool allocator just for certain containers, so even though they aren't exactly smart pointers there are definitely instances where you might want to use an allocator only for a specific class or classes.