符合stl标准的allocator中能含有非静态成员变量吗？

Frahm

我想把一个pool封装成符合stl标准的allocator,所以在自己写的allocator内部private区加了一个pool对象，因为内存是被pool管理的，所以内存是在pool被析构的时候释放所有pool中的内存，然而这个封装完的allocator在给std::vector和std::list用时，会诡异地崩掉，我可以保证pool这个类是正常工作的，我感觉问题就是出在allocator被析构的时候，这时我把它分配的内存都回收了，我感觉这应该很合理才对，因为allocator被析构说明由它分配的内存不会被使用，否则析构后不可能调用deallocate()回收，为此我写了一个模仿pool类行为的测试用allocator, 它在被析构时也会释放所有申请的内存，在std::vector和std::list的测试下，也都崩溃。
那么这是怎么一回事呢？
下面的是测试用的会出问题的allocator代码:

1. 
   
2. template<typename T>
   
3. class FakePool {
   
4. public:
   
5.         typedef T value_type;
   
6.         typedef T* pointer;
   
7.         typedef const T* const_pointer;
   
8.         typedef T& reference;
   
9.         typedef const T& const_reference;
   
10.         typedef std::size_t size_type;
    
11.         typedef std::ptrdiff_t difference_type;
    
12. 
    
13.         template<typename U>
    
14.         struct rebind {
    
15.                 typedef FakePool<U> other;
    
16.         };
    
17. public:
    
18.         FakePool() {
    
19.                 std::cout << typeid(*this).name() << " constructed\n";
    
20.         }
    
21. 
    
22.         template<typename U>
    
23.         explicit FakePool(const FakePool<U>&) {}
    
24. 
    
25.         ~FakePool() {
    
26.                 std::cout << typeid(*this).name() << " destructed\n";
    
27.                 for(void* ptr : ptrs_) {
    
28.                         ::operator delete(ptr);
    
29.                 }
    
30.         }
    
31. 
    
32.         pointer allocate(size_type n, const void* = nullptr) {
    
33.                 void* ptr = ::operator new(sizeof(T) * n);
    
34.                 ptrs_.push_back(ptr);
    
35.                 return (pointer)ptr;
    
36.         }
    
37. 
    
38.         void deallocate(pointer ptr, size_type) {
    
39.                 Assert(ptr != nullptr);
    
40.                 auto iter = std::find(ptrs_.begin(), ptrs_.end(), ptr);
    
41.                 Assert(iter != ptrs_.end());
    
42.                 ptrs_.erase(iter);
    
43.                 ::operator delete(ptr);
    
44.         }
    
45.        
    
46.         inline void construct(pointer ptr, const_reference copy) {
    
47.                 new(ptr) T(copy);
    
48.         }
    
49. 
    
50.         inline void destroy(pointer ptr) {
    
51.                 ptr->~T();
    
52.         }
    
53. 
    
54.         inline pointer address(reference val) const {
    
55.                 return std::addressof(val);
    
56.         }
    
57. 
    
58.         inline const_pointer address(const_reference val) const {
    
59.                 return std::addressof(val);
    
60.         }
    
61. 
    
62.         inline size_type max_size() const {
    
63.                 return (size_type)(-1) / sizeof(T);
    
64.         }
    
65. 
    
66. private:
    
67.         std::vector<void*> ptrs_;
    
68. };
    
69. 
    
70. //测试代码
    
71. int main() {
    
72.             {
    
73.         std::list<int, core::FakePool<int> > myls;
    
74.         myls.push_back(12);
    
75.         std::cout << myls.front() << '\n';
    
76.         }
    
77.     return 0;
    
78. }
    

复制代码

注: Assert是我写的类似assert的函数

windoze

在C++11之前，不行，allocator必须是无状态的
在C++11中可以，但是你要去仔细看std::scoped_allocator_adaptor的文档，记得要仔细看………………

Frahm

回复 2# windoze


    多谢指点。