Question

我正在尝试创建一个可以使用list和map等容器的简单池分配器。首先，我有一个类free_list，它继承自容器使用的节点类型，并使用一个专门的前向链表（所有内存已经分配 - 当分配器分配第一个项时发生分配）给予和收回分配器的allocate和deallocate函数中请求的内存。然后我有类pool_alloc，它实现了分配器本身，并在其分配和释放函数free_list<T>对象类型中返回并接受。

问题孩子就是这句话：m_next->give_back(ptr);在pool_alloc::deallocate下，它返回VC12错误C2664：它说我无法从类型“free_list<T>*”转换为类型“free_list<free_list<T>>* ”。

我不明白为什么free_list<T>::give_back期望类型为free_list<free_list<T>>*，而人们期望它free_list<T>*。

有什么方法可以解决这个问题吗？

完整的源代码如下：

#include <algorithm>

template<class T>
class free_list : public T {
public:
    free_list* init(std::size_t num_elements) {

        m_next = this;
        free_list* temp = m_next + 1;

        free_list* runner = m_next;
        for (std::size_t s = 1; s < num_elements; ++s) {
            runner->m_next = temp;
            runner = temp;
            temp = runner + 1;
        }
        runner->m_next = nullptr;

        return m_next;
    }

    free_list* obtain() {
        free_list* head = m_next;
        m_next = m_next->m_next;
        return head;
    }

    void give_back(free_list* ptr) {
        ptr->m_next = m_next;
        m_next = ptr;
    }

    free_list* m_next;

};

template<class T>
class pool_alloc {
    typedef pool_alloc<T> myt;

public:
    typedef std::size_t size_type;
    typedef std::ptrdiff_t difference_type;
    typedef free_list<T> value_type;
    typedef T& reference;
    typedef const T& const_reference;
    typedef free_list<T>* pointer;
    typedef const free_list<T>* const_pointer;

    template<class U>
    struct rebind {
        typedef pool_alloc<U> other;
    };

    pool_alloc() : data(nullptr), m_next(nullptr), capacity(4096), allocated(0) {}
    pool_alloc(std::size_t capacity) : data(nullptr), m_next(nullptr), capacity(capacity), allocated(0) {}

    T* address(reference ref) {
        return &ref;
    }

    const T* address(const_reference ref) const {
        return &ref;
    }

    std::size_t max_size() const {
        return capacity;
    }

    pointer allocate(std::size_t) {
        if (allocated >= capacity) throw(std::bad_alloc());
        if (allocated == 0) {
            data = (void*) new char[capacity * sizeof(free_list<T>)];
            m_next = static_cast<free_list<value_type>*>(data);
            m_next->init(capacity);
        }
        return m_next->obtain();
    }

    void deallocate(pointer ptr, std::size_t) {
        m_next->give_back(ptr);
        --allocated;
        if (allocated == 0) {
            delete[](char*)(data);
            data = nullptr;
            m_next = nullptr;
        }
    }

    template<class T, class... Args>
    void construct(T* ptr, Args&&... args) {
        ::new ((void*) ptr) T(std::forward<Args>(args)...);
    }

    template <class T>
    void destroy(T* ptr) {
        ptr->~T();
    }

    bool operator==(const myt& other) {
        return (char)(data) == (char)(other.data);
    }

    bool operator!=(const myt& other) {
        return !operator==(other);
    }

private:

    void* data;
    free_list<value_type>* m_next;
    std::size_t capacity;
    std::size_t allocated;

};

Answer 1

这并不奇怪：您已将value_type（错误地）定义为free_list<T>而不是T，因此m_next的类型为free_list<free_list<T>>。 pointer和const_pointer有同样的问题。

其他问题：

pool_alloc没有定义适当的复制/移动/赋值运算符。
pool_alloc没有接受const pool_alloc<U>&的模板化构造函数，因此您将无法初始化

pool_alloc::allocate

std::vector<T, pool_alloc<T>>会做出可怕的事情。如果参数大于1，您应该断言参数为1或回退到::operator new(n * sizeof(T))。
operator==和operator!=应该是const。
construct和destroy也可能是const，甚至static。
没有必要同时保留data和m_next，因为它们是相同值的不同类型别名 - 只要您需要m_next到void* { {1}}。
转储data而不是deallocate中的内存块可能会导致例如~pool_alloc的病态性能。
std::stack<T, std::list<T, pool_alloc<T>>中的“list”初始化将每个节点的free_list<T>::init指针指向自身，而不是构建列表。应该是：
```
m_next
```

尝试创建池分配器时VC12中的奇怪错误消息

1 个答案: