std：：unordered_map 的自定义分配器

问：

我正在尝试将我的自定义分配器用于 .分配器已经适用于我自己的对象，也适用于，但是当我尝试以相同的方式使用它时，我收到来自 hashtable.h 的错误消息：std::unordered_mapstd::vectorstd::unordered_map

/usr/include/c++/11/bits/hashtable.h:204:21: error: static assertion failed: unordered container must have the same value_type as its allocator
  204 |       static_assert(is_same<typename _Alloc::value_type, _Value>{},

我尝试使用自定义分配器的类：

class a {
  public:
  /**
   * @brief Creates a A managed by an shared ptr.
   */
  [[nodiscard]] static std::shared_ptr<a> create();

  /**
   * @brief Creates a B as part of A.
   * @tparam T The type of the b. (There are different Bs, but all inherit from the origin class B)
   * @param args Arguments to pass to b.
   * @return The b.
   */
  template<typename T, typename... Args>
  T* create_b(Args&&... args) {
    std::unique_ptr<T> b = std::make_unique<T>(std::forward<Args>(args)...);
    Bs_.push_back(std::move(b));
    return static_cast<T*>(Bs_.back().get());
  }

  /**
   * @brief Overloaded new operator to use the custom allocator.
   */
  void* operator new(std::size_t size)
  {
    tlsf_allocator allocator;
    return allocator.allocate<a>(size);
  }

  /**
   * @brief Overloaded delete operator to use the custom deallocator.
   */
  void operator delete(void* ptr)
  {
    tlsf_allocator allocator;
    allocator.deallocate<a>(static_cast<a*>(ptr), 1);
  }

  private:
  // CTOR is private to prevent constructing a class object without being managed by a shared_ptr.
  a();

  //std::unordered_map<const i_b*, c*, std::hash<const i_b*>, std::equal_to<const i_b*>> Bs_to_Cs_{};//working fine, but no custom allocator

  std::unordered_map<const i_b*, c*, std::hash<const i_b*>, std::equal_to<const i_b*>, tlsf_allocator::allocator_for<std::pair<const i_b*, c*>>> Bs_to_Cs_{}; // Error

  std::vector<std::unique_ptr<i_b>, tlsf_allocator::allocator_for<std::unique_ptr<i_b>>> Bs_{};//working fine, even with custom allocator
};

我的自定义分配器：

/**
 * @class tlsf_allocator
 * @brief A custom allocator class that uses TLSF (Two-Level Segregated Fit) for memory allocation.
 */
class tlsf_allocator {
  public:
  /**
   * @brief Allocates memory for 'n' elements of type 'T'.
   *
   * @tparam T The type of elements to allocate memory for.
   * @param n The number of elements to allocate memory for.
   * @return A pointer to the allocated memory block.
   *
   * This function allocates memory for 'n' elements of type 'T' using TLSF memory management.
   * It returns a pointer to the allocated memory block.
   */
  template<typename T>
  T* allocate(size_t n) {
    T* result = reinterpret_cast<T*>(tlsf_malloc(get_tlsf_pool(), sizeof(T) * n));
    if (result == nullptr) {
      throw std::bad_alloc();    // not enough memory to allocate new the object
    }
    return result;
  }

  /**
   * @brief Deallocates memory block at the given pointer.
   *
   * @tparam T The type of the memory block being deallocated.
   * @param ptr A pointer to the memory block to deallocate.
   * @param n The number of elements in the memory block (unused in this implementation), but required for
   * std::allocator_traits.
   *
   * This function deallocates the memory block at the given pointer using TLSF memory management.
   * The 'n' parameter is unused in this implementation but kept for compatibility with the allocator concept.
   */
  template<typename T>
  void deallocate(T* ptr, [[maybe_unused]] size_t n) {
    tlsf_free(get_tlsf_pool(), ptr);
  }

  /**
   * @struct allocator_for
   * @brief An allocator adaptor for providing the tlsf_allocator to STL containers.
   *
   * This allocator adaptor is used to provide the tlsf_allocator functionality to STL containers
   * like std::vector. It is used as a template parameter when declaring a container with the
   * desired element type. This allows the container's memory allocation and deallocation operations
   * to be managed by the tlsf_allocator.
   *
   * @tparam U The type of the elements that the allocator should allocate memory for.
   */
  template<typename U>
  struct allocator_for {
    /**
     * @brief Type alias for the element type managed by the allocator adaptor.
     *
     * This type alias defines the type of elements that the allocator adaptor manages.
     * It is used to provide information about the element type to the STL containers
     * that use this allocator.
     */
    using value_type = U;

    /**
     * @brief Default constructor.
     */
    allocator_for() noexcept = default;

    /**
     * @brief Copy constructor.
     *
     * @tparam V Another type.
     * @param other Another allocator_for instance.
     */
    template<typename V>
    explicit allocator_for([[maybe_unused]] const allocator_for<V>& other) noexcept {}

    /**
     * @brief Allocate memory for elements.
     *
     * @param n The number of elements to allocate memory for.
     * @return A pointer to the allocated memory block.
     */
    U* allocate(std::size_t n) {
      tlsf_allocator allocator;
      return reinterpret_cast<U*>(allocator.allocate<U>(n));
    }

    /**
     * @brief Deallocate memory for elements.
     *
     * @param p A pointer to the memory block to deallocate.
     * @param n The number of elements.
     */
    void deallocate(U* p, std::size_t n) noexcept {
      tlsf_allocator allocator;
      allocator.deallocate<U>(p, n);
    }
  };

  private:
  /**
   * @brief Gets the TLSF memory pool.
   *
   * @return A reference to the TLSF memory pool.
   *
   * This static function returns a reference to the TLSF memory pool used by the allocator.
   * It ensures that a single memory pool is shared among all instances of the allocator.
   */
  static tlsf_t& get_tlsf_pool();
};

我看过示例代码。每次都使用，但似乎对我不起作用。看起来我的分配器似乎以某种方式使用了错误的value_type。pair<const key, value>std::unordered_map

我还尝试编写自己的 unordered_map 类，该类在内部使用，但重新定义了 new 和 delete。我知道通常编写自己的 unordered_map 类对于使用自定义分配器是没有必要的，但是由于我的第一次尝试失败了，我想尝试将其作为第二种方法。错误是一样的，所以我放弃了这种方法。std::unordered_mapstd::unordered_map

我知道使用自定义分配器是一种特殊情况。我想使用它，因为我在嵌入式环境中运行，并且想在静态内存上使用 tlsf 内存分配。此外，我希望我的自定义分配器创建的所有对象都在同一tlsf_pool中。因此，我无法给出 a ，因为这会导致该方法返回不同的内存区域。在这一点上，这足以在我的自定义分配器上运行我自己的类。但是，由于我还想分配和覆盖我的自定义分配器，因此我给自己编写了一个分配器适配器 （），用于向 STL 容器提供tlsf_allocator。然后，它还具有模板参数 u，因此也可以使用 value_type = U;。class tlsf_allocatortemplate<typename T>static tlsf_t& get_tlsf_pool();std::vectorstd::unordered_mapstruct allocator_for

这足以分配 ，但我失败了。std::vectorstd::unordered_map