通过reinterpret_cast和std::launder进行存储访问。

Posted 2021-03-19

我创建了一个内存池，以便将其用作对象的新位置，我使用空闲的插槽来拥有一个自由列表，以便重复使用插槽。

template<class T>
class ObjectPool {
public:
    ObjectPool( std::size_t cap );
    virtual ~ObjectPool();
    void* allocate() noexcept(false);
    void deallocate( void* ptr );
private:
    template<typename M>
    static constexpr const M& max( const M& a, const M& b ) {
        return a < b ? b : a;
    }
    using storage = typename std::aligned_storage<max(sizeof(T), sizeof(T*)), std::alignment_of<T>::value>::type;
    storage* pool;
    std::mutex mutex;
    std::size_t capacity;
    std::size_t counter;
    T* deletedItem;
};

template<class T>
ObjectPool<T>::ObjectPool( std::size_t cap ) :
        capacity(cap), counter(0), deletedItem(nullptr) {
    if ( capacity > 0 )
        pool = ::new storage[cap];
    else
        pool = nullptr;
}

template<class T>
ObjectPool<T>::~ObjectPool() {
    ::delete[] pool;
}

template<class T>
void* ObjectPool<T>::allocate() noexcept(false) {
    std::lock_guard<std::mutex> l(mutex);
    if ( deletedItem ) {
        T* result = deletedItem;
        deletedItem = *(reinterpret_cast<T**>(deletedItem)); //<-----undefined behavior??
        return result;
    }

    if ( counter >= capacity ) {
        throw std::bad_alloc();
    }

    return std::addressof(pool[counter++]);
}

template<class T>
void ObjectPool<T>::deallocate( void* ptr ) {
    std::lock_guard<std::mutex> l(mutex);
    *(reinterpret_cast<T**>(ptr)) = deletedItem;  //<-----undefined behavior??
    deletedItem = static_cast<T*>(ptr);
}

我想知道这个类在C++17标准下是否有未定义的行为？是否需要使用 std::launder? 根据我的理解，它不是，因为只有void指针和 T 涉及到指针。另外当在 deallocate 对象已经被销毁，所以它应该是安全的。

答案

你的代码在 每一 C++标准，甚至是允许（在某些情况下）隐式创建对象的C++20。但不是因为与以下原因有关的原因 launder.

你不能只是拿一段记忆，假装有一个... T* 那里，并把它当作一个存在。是的，即使是像指针这样的基本类型。你必须 创造 对象，然后再使用它们。所以，如果你有一块废弃的内存，而你想把一个叫做 T* 到它，你需要用 placement-new 创建一个。

所以，让我们重写你的代码（注意，这是在编译，但在其他方面是未经测试的；主要的一点是，你必须创建你的链接列表的元素）。

template<class T>
class ObjectPool {
public:
    ObjectPool( std::size_t cap );
    virtual ~ObjectPool();
    void* allocate() noexcept(false);
    void deallocate( void* ptr );
private:

    using empty_data = void*; //The data stored by an empty block. Does not point to a `T`.
    using empty_ptr = empty_data*; //A pointer to an empty block.

    static constexpr size_t entry_size = std::max(sizeof(T), sizeof(empty_data));
    static constexpr std::align_val_t entry_align =
      std::align_val_t(std::max(alignof(T), alignof(empty_data))); //Ensure proper alignment

    void* pool;
    std::mutex mutex;
    std::size_t capacity;
    //std::size_t counter;  //We don't need a counter; the pool is empty if `freeItem` is NULL
    empty_ptr freeItem; //Points to the first free item.
};

template<class T>
ObjectPool<T>::ObjectPool( std::size_t cap ) :
    pool(::operator new(entry_size * cap, entry_align)),
    capacity(cap)
{
    //Build linked-list of free items, from back to front.
    empty_data previous = nullptr; //Last entry points to nothing.
    std::byte *byte_pool = reinterpret_cast<std::byte*>(pool); //Indexable pointer into memory
    auto curr_ptr = &byte_pool[entry_size * capacity]; //Pointer to past-the-end element.
    do
    {
        curr_ptr -= entry_size;

        //Must *create* an `empty_data` in the storage.
        empty_ptr curr = new(curr_ptr) empty_data(previous);
        previous = empty_data(curr); //`previous` now points to the newly-created `empty_data`.
    }
    while(curr_ptr != byte_pool);

    freeItem = empty_ptr(previous);
}

template<class T>
ObjectPool<T>::~ObjectPool()
{
    ::operator delete(pool, entry_size * capacity, entry_align);
}

template<class T>
void* ObjectPool<T>::allocate() noexcept(false) {
    std::lock_guard<std::mutex> l(mutex);
    if(!freeItem) { throw std::bad_alloc(); } //No free item means capacity full.

    auto allocated = freeItem;
    freeItem = empty_ptr(*freeItem); //Next entry in linked list is free or nullptr.
    return allocated;
}

template<class T>
void ObjectPool<T>::deallocate( void* ptr ) {
    std::lock_guard<std::mutex> l(mutex);

    //Must *create* an `empty_data` in the storage. It points to the current free item.
    auto newFree = new(ptr) empty_data(freeItem);
    freeItem = newFree;
}