在std::scoped_allocator_adaptor中使用带有std::unordered_map的自定义分配器

我正在尝试将一个简单的内存池分配器与std::unordered_map一起使用。我在std::string和std::vector中似乎都成功地使用了相同的分配器。我希望包含在unordered_map（和向量）中的项也使用这个分配器，所以我已经将分配器封装在std::scoped_allocator_adaptor中。

简化定义集：

template <typename T>
using mm_alloc = std::scoped_allocator_adaptor<lake_alloc<T>>;
using mm_string = std::basic_string<char, std::char_traits<char>, mm_alloc<char>>;
using mm_vector = std::vector<mm_string, mm_alloc<mm_string>>;
using mm_map = std::unordered_map<mm_string, mm_vector, std::hash<mm_string>, std::equal_to<mm_string>, mm_alloc<std::pair<mm_string, mm_vector>>>;

初始化为：

lake pool;
mm_map map { mm_alloc<std::pair<mm_string, mm_vector>>{pool} };

lake_alloc与迭代器代码的其余部分如下所示。我在Clang 3.3中得到的错误是，它不能将其allocator_type（在本例中为字符串对向量的mm_alloc）设置为自己的__pointer_allocator。这是用于哈希映射实现的内部类型。部分错误输出如下：

lib/c++/v1/__hash_table:848:53: error: no matching conversion for functional-style
      cast from 'const allocator_type' (aka 'const std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<std::__1::pair<std::__1::basic_string<char,
      std::__1::char_traits<char>, std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<char, krystal::lake> > >, std::__1::vector<std::__1::basic_string<char,
      std::__1::char_traits<char>, std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<char, krystal::lake> > >,
      std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<std::__1::basic_string<char, std::__1::char_traits<char>,
      std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<char, krystal::lake> > >, krystal::lake> > > >, krystal::lake> >') to '__pointer_allocator' (aka
      'std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<std::__1::__hash_node<std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>,
      std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<char, krystal::lake> > >, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>,
      std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<char, krystal::lake> > >, std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<std::__1::basic_string<char,
      std::__1::char_traits<char>, std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<char, krystal::lake> > >, krystal::lake> > > >, void *> *, krystal::lake> >')
    : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
                                                    ^~~~~~~~~~~~~~~~~~~~~~~

GCC 4.7.1在其哈希图内部结构中给了我一个类似的错误，所以很明显我做错了，但这是我第一次尝试STL中的分配器，我不知所措。

下面是自定义分配器。这是一个简单的实现，其中有一些漏洞，但这个版本在包含向量和字符串中有几兆字节数据的测试用例中运行良好。

#include <cstddef>
#include <memory>
#include <scoped_allocator>
class lake {
    const size_t block_size_;
    mutable std::vector<std::unique_ptr<uint8_t[]>> blocks_;
    mutable uint8_t *arena_, *pos_;
    static constexpr const size_t DefaultBlockSize = 48 * 1024;
    void add_block(size_t of_size) const {
        blocks_.emplace_back(new uint8_t[of_size]);
        pos_ = arena_ = blocks_.back().get();
    }
    inline void add_block() const { add_block(block_size_); }
public:
    lake(const size_t block_size)
    : block_size_ {block_size}
    {
        add_block();
    }
    lake() : lake(DefaultBlockSize) {}
    void* allocate(size_t n) const {
        if (pos_ + n - arena_ > block_size_) {
            if (n > block_size_)
                add_block(n); // single-use large block
            else
                add_block();
        }
        auto result = pos_;
        pos_ += n;
        return result;
    }
    void deallocate(void* p, size_t n) const {
    }
};

template <typename T, typename Alloc>
class krystal_alloc {
    const Alloc* allocator_;
public:
    using value_type = T;
    using size_type = size_t;
    using difference_type = ptrdiff_t;
    using pointer = T*;
    using const_pointer = const T*;
    using reference = T&;
    using const_reference = const T&;
    template <typename U>
    struct rebind { typedef krystal_alloc<U, Alloc> other; };
    krystal_alloc() : allocator_{ new Alloc() } {} // not used
    krystal_alloc(const Alloc& alloc) : allocator_{ &alloc } {}
    pointer address(reference v) {
        return 0;
    }
    const_pointer address(const_reference v) {
        return 0;
    }
    size_type max_size() const {
        return static_cast<size_type>(-1) / sizeof(value_type);
    }
    pointer allocate(size_type n) {
        return static_cast<pointer>(allocator_->allocate(sizeof(T) * n));
    }
    void deallocate(pointer p, size_type n) {
        allocator_->deallocate(p, n);
    }
};
template <typename T, typename Alloc, typename U>
inline bool operator==(const krystal_alloc<T, Alloc>&, const krystal_alloc<U, Alloc>) { return true; }
template <typename T, typename Alloc, typename U>
inline bool operator!=(const krystal_alloc<T, Alloc>&, const krystal_alloc<U, Alloc>) { return false; }

// -- standard usage
template <typename T>
using lake_alloc = krystal_alloc<T, lake>;