Keeping track of STL container memory usage

The topic says most of it.

I'm having fun with various algorithms and their performance, and I've written a handler class that runs the various algorithms and displays statistics afterwards.

I remember a thread about insertion sort by RichSelian where he displayed statistics from various sorting algorithms - I'm trying to do almost exactly the same thing, except I'm not testing sorting algorithms.
All my algorithm functor classes derive from a base class which has some pure virtual functions the specific derivatives have to define, and then it defines a wrapper around new, which the algorithm functors will be calling every time they do a manual allocation. But this solution doesn't work with STL containers, and one of the main reasons I'm doing this is to measure performance between the dynamically resizable STL containers and arrays.


Will I have to write a custom allocator for the STL containers or something in that direction?

I'd really appreciate any information on this subject - links, tips, "no, that's stupid", etc.

Thanks for reading.

I don't know if .capacity() would suit your needs, since you probably don't want to check it all the time. But that was the whole point of the custom allocator in the STL, so far as I know, was to give a way to use custom-new and custom-delete.

I've never dealt with custom allocators, so I can't help much there. If you've got something written, it might not be that much more work to make it fit the std allocator criteria (I can probably quote what the standard says needs to be defined, if necessary).

Custom allocator is good

Code:

---

#include <vector>
#include <iostream>

template<class T>
class talloc: public std::allocator<T>
{

public:
      pointer allocate( size_type _Count, const void* _Hint)
      {
            //return new(_Count* sizeof(T));
            return std::allocator<T>::allocate( size_type _Count, const void* _Hint);
      }
      void deallocate(pointer _Ptr, size_type _Count)
      {
            //for(pointer p =0; p <_Count; ++p)
            //        delete (_Ptr+p);
            std::allocator<T>::deallocate(pointer _Ptr, size_type _Count);
      }
};

int main()
{
      std::vector<int, talloc<int>> tv(10);
      tv.push_back(23);
      std::cout << tv.back();
      return 0;
}

---