編寫自定義分配器

Question

我正在嘗試編寫一個自定義分配器，該分配器為固定數量的元素預分配了空間。 但是，我在理解需求方面存在一些問題。

allocator.h

#pragma once
#ifndef _ALLOCATOR_H
#define _ALLOCATOR_H

template<typename T>
class Allocator
{
public:
    //    typedefs
    typedef T value_type;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef std::size_t size_type;
    typedef std::ptrdiff_t difference_type;

public:
    //    convert an allocator<T> to allocator<U>
    template<typename U>
    struct rebind
    {
        typedef Allocator<U> other;
    };

public:
    explicit Allocator(void)
    {
        mCurElement = 0;
        mMaxElements = 650000000;
        mBase = reinterpret_cast<pointer>(::operator new(mMaxElements * sizeof(T)));
    }

    virtual ~Allocator(void)
    {
        ::operator delete(mBase);
    }

    explicit Allocator(Allocator const &oOther)
    {
        mCurElement = oOther.mCurElement;
        mMaxElements = oOther.mMaxElements;
        mBase = oOther.mBase;
    }

    template<typename U>
    explicit Allocator(Allocator<U> const &oOther)
    {
        mCurElement = 0;
        mMaxElements = 650000000;
        mBase = oOther.mBase;
    }

    //    address
    pointer address(reference r) { return &r; }
    const_pointer address(const_reference r) { return &r; }

    //    memory allocation
    pointer allocate(size_type nElements, typename std::allocator<void>::const_pointer = 0)
    {
        if (mCurElement > mMaxElements)
            return NULL;

        //pointer p = reinterpret_cast<pointer>(::operator new(cnt * sizeof(T)));
        pointer p = &mBase[mCurElement];
        mCurElement += nElements;
        return p;
    }
    void deallocate(pointer pAddress, size_type)
    {
        //::operator delete(pAddress);
        mCurElement--;
    }

    //    size
    size_type max_size() const
    {
        return std::numeric_limits<size_type>::max() / sizeof(T);
    }

    //    construction/destruction
    void construct(pointer pAddress, const T& oObject)
    {
        new(pAddress) T(oObject);
    }
    void destroy(pointer pAddress)
    {
        pAddress->~T();
    }

    bool operator==(Allocator const&) { return true; }
    bool operator!=(Allocator const& oAllocator) { return !operator==(oAllocator); }

public:
    T *getBase(void) const { return mBase; }

private:
    static usize_t mId;
    T *mBase;
    usize_t mMaxElements;
    usize_t mCurElement;
};


#endif // _ALLOCATOR_H

allocator.cpp

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <sstream>
#include <set>
#include <ctime>

#include "allocator.h"

typedef unsigned int uint_t;
typedef unsigned long long usize_t;
usize_t Allocator<usize_t>::mId;

void testStdAllocator(usize_t nIterations, usize_t nMaxValue)
{
    std::set<usize_t, std::less<usize_t>, Allocator<usize_t>> st;
    std::string id = "Standard Set";

    clock_t start = clock();
    for (usize_t i = 0; i < nIterations; i++)
    {
        usize_t val = (usize_t)(rand() % nMaxValue) + 1;
        if (i % 1000000 == 0)
            std::cout << id << " testing ... " << i << "/" << nIterations << "\r";

        st.insert(val);
    }

    std::cout << id << " Elapsed: " << clock() - start << std::endl;
}

int main(int argc, char *argv[])
{
    usize_t iterations =    650000000;
    usize_t val =           6500000;

    std::cout << "Allocator" << std::endl;

    testStdAllocator(iterations, val);

    return 0;
}

我有的問題是：

為什么需要template <typename U> ... ？ （我找到了一個例子並采用了它）

當我使其可編譯並對其進行測試時， std::set顯然會創建分配器的副本，因此我將不得不傳遞指針。 我可以為此使用std::shared_ptr ，但是我真的不明白為什么首先需要這樣做。

顯然，代理容器存在一些需要template <typename U>的地方，但這又帶來了另一個問題，即（顯然）不同的分配器類型傳遞了指針。

因此，我將感謝一些我犯錯的地方。

Answer 1

當您將分配器傳遞給std::set<T, C A>它意味着要為T對象提供一個allocate()函數allcoating空間。 但是， std::set<T, C, A>將不會分配任何T對象。 相反，它將分配_Node<T>對象，其中_Node是一些樹節點表示形式， _Node可以保存T對象，又可以包含指向其他節點的合適指針。

要分配_Node<T>的對象，需要基於A的分配器。 此分配器的類型是從A::rebind<_Node<T>>::other並通過將原始分配器對象（或從其創建的對象）作為構造函數參數進行了適當的初始化。

當然，使用有狀態分配器確實假定您使用的是C ++ 11分配器模型。 在C ++ 11之前，分配器沒有適當地構造其他分配器，並且它們基本上是無狀態的。 如果您需要使用C ++ 11之前的代碼但要處理分配器，則可能要使用BSL中的容器：這些容器可以識別分配器，並且可以使用C ++ 03編譯器進行編譯。