Thread: 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.

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;
}