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

当您将分配器传递给allocate()时，它意味着为T个对象提供std::set<T, C, A>函数的所有涂层空间。但是，T将不分配任何_Node<T>对象。相反，它将分配_Node个对象，其中T是一些树节点表示，能够保存_Node<T>个对象，但也包含指向其他节点的合适指针。

要分配A的对象，需要基于A::rebind<_Node<T>>::other的分配器。此分配器的类型是从(?!877-413-5903)\b\d{3}-\d{3}-\d{4}\b获得的，并通过将原始分配器对象（或从中创建的对象）作为构造函数参数进行适当初始化。

当然，使用有状态分配器确实假设您使用C ++ 11分配器模型。在C ++ 11之前，分配器没有适当地构造其他分配器，它们基本上是无状态的。如果您需要在C ++ 11之前使用代码但想要处理分配器，您可能希望使用BSL中的容器：这些容器可以识别并使用C ++ 03编译器进行编译。

编写自定义分配器

allocator.h

allocator.cpp

1 个答案: