c++ - 如何获得 std::map 的真正分配器？

Question

我想为 STL 映射容器打印我的自定义内存分配器的工作结果。我想打印内存分配图。
我对 get_allocator() 有疑问。请参阅示例。
get_allocator()调用给出初始 pair<int,int> 的分配器.它甚至创造了它......

有没有办法获得真正的分配器(Pool 的实例 RBtree )，它为 map 的元素提供内存？

我正在使用 gcc。谢谢。

#include <memory>
#include <map>
using namespace std;
class Pool {
  //...
public:
  Pool(unsigned n);
  ~Pool();
  void* alloc();  
  void free(void*);
  void print_mm();  //print pool map
  //...
};
void* Pool::alloc() {
  //...
}
//...
void Pool::print_mm() {
  //...
}
template<class T> class Pool_alloc : public allocator<T> {
  static Pool pool;
public:
  template<class U> struct rebind {
    typedef Pool_alloc<U> other;
  };
  template<class U> Pool_alloc(const Pool_alloc<U>&) {}
  Pool_alloc() {}
  T* allocate(size_t, void*);
  void deallocate(T*, size_t);
  void print_mm() {pool.print_mm();}
};
template<class T> Pool Pool_alloc<T>::pool(sizeof(T));
template<class T> T* Pool_alloc<T>::allocate(size_t n, void* = 0) {
   //...
   return p;
}
template<class T> void Pool_alloc<T>::deallocate(T* p, size_t n) {
   //...
}
main() {
  map<int, int, less<int>, Pool_alloc<pair<int, int> > > m;
  m[144] = 12;
  m.get_allocator().print_mm();  //doesn't work - it gives the wrong allocator :-(
}

接下来是示例的完整代码 - 它的基础来自著名的 Bjarne Stroustrup 的书。 ;-)

#include <iostream>
#include <memory>
#include <map>
using namespace std;
class Pool {
   struct Link {Link *next;};
   struct Chunk {
      static const unsigned size = 8192 - sizeof(Chunk*); //page boundary
      Chunk *next;
      char mem[size];
   } *chunks;
   Link *head;  //pointer to first free link
   Pool(Pool&);  //disable
   void operator=(Pool&); //disable
   void grow();
public:
   const unsigned int atomsize;
   Pool(unsigned n);  //n - number of atoms
   ~Pool();
   void* alloc();  //for one atom
   void free(void*);
   void print_mm();  //print pool memory map
};
void* Pool::alloc() {
   if (head == 0) grow();
   Link *p = head;
   head = p->next;
   return p;
}
void Pool::free(void *b) {
   Link *p = static_cast<Link*>(b);
   p->next = head;
   head = p;
}
Pool::Pool(unsigned sz): atomsize(sz < sizeof(Link*) ? sizeof(Link*) : sz) {
   cout << "atom size = " << atomsize << " bytes\n";
   head = 0;
   chunks = 0;
}
Pool::~Pool() {
   Chunk *p = chunks;
   while (p) {
      Chunk *q = p;
      p = p->next;
      delete q;
   }
}
void Pool::grow() {
   Chunk *p = new Chunk;
   p->next = chunks;
   chunks = p;
   const unsigned noe = Chunk::size/atomsize;
   char *start = p->mem, *last = start + (noe - 1)*atomsize;
   for (char *p = start; p < last; p += atomsize)
      ((Link*)p)->next = (Link*)(p + atomsize);
   ((Link*)last)->next = 0;
   head = (Link*)start;
}
void Pool::print_mm() {
   cout << "The pool memory map\n";
   ///...
}
template<class T> class Pool_alloc : public allocator<T> {
   static Pool pool;  //static for STL
public:
   template<class U> struct rebind {
      typedef Pool_alloc<U> other;
   };
   template<class U> Pool_alloc(const Pool_alloc<U>&) {}
   Pool_alloc() {}
   T* allocate(size_t, void*);
   void deallocate(T*, size_t);
   static void print_mm() {pool.print_mm();}
};
template<class T> Pool Pool_alloc<T>::pool(sizeof(T));
template<class T> T* Pool_alloc<T>::allocate(size_t n, void* = 0) {
   T* p;
   if (n == 1)
      p = static_cast<T*>(pool.alloc());
   else
      p = static_cast<T*>(allocator<T>::allocate(n));    //STL level
      //p = static_cast<T*>(operator new (sizeof(T)*n));  //OS level
   return p;
}
template<class T> void Pool_alloc<T>::deallocate(T* p, size_t n) {
   if (n == 1)
      pool.free(p);
   else
      allocator<T>::deallocate(p, n);  //STL level
      //operator delete(p);  //OS level
}
main() {
   map<int, int, less<int>, Pool_alloc<pair<int, int> > > m;
   m.insert(pair<int,int>(7, 8));
   for (int i(0); i < 200; ++i)
      m[i*i] = 2*i;
   m.erase(169);
   m.erase(121);
   m[5] = 88;
   cout << m[7] << '-' << m[5] << '-' << m.size() << endl;
   m.get_allocator().print_mm();  //doesn't work - it gives the wrong allocator :-(
}

Answer 1

试试这个:

template<class T, Pool* pool> class Pool_alloc : public allocator<T> {
public:
  template<class U> struct rebind {
    typedef Pool_alloc<U, pool> other;
  };

这需要您的 Pool支持不同大小的数据。

或者，替换 Pool与 Pool<sizeof(T)> , 也许使用 static分配单例实例的方法技巧，那么您至少可以找到各种大小的分配器。 (他们可以在全局池中注册自己，以便您以后可以找到它们)。

然后你的池分配器可以足够聪明地为请求的不同大小的数据使用不同大小的 block 。或不，如你所愿。