static allocator

#include <iostream>
using namespace std;

namespace jj09
{

    class allocator
    {
    private:
        struct obj
        {
            struct obj *next; //embedded pointer
        };

    public:
        void *allocate(size_t);
        void deallocate(void *, size_t);
        void check();

    private:
        obj *freeStore = nullptr;
        const int CHUNK = 5; //小一點方便觀察
    };

    void *allocator::allocate(size_t size)
    {
        obj *p;

        if (!freeStore)
        {
            //linked list 是空的，所以攫取一大塊 memory
            size_t chunk = CHUNK * size;
            freeStore = p = (obj *)malloc(chunk);

            //cout << "empty. malloc: " << chunk << "  " << p << endl;

            //將分配得來的一大塊當做 linked list 般小塊小塊串接起來
            for (int i = 0; i < (CHUNK - 1); ++i)
            { //沒寫很漂亮, 不是重點無所謂.
                p->next = (obj *)((char *)p + size);
                p = p->next;
            }
            p->next = nullptr; //last
        }
        p = freeStore;
        freeStore = freeStore->next;

        //cout << "p= " << p << "  freeStore= " << freeStore << endl;

        return p;
    }
    void allocator::deallocate(void *p, size_t)
    {
        //將 deleted object 收回插入 free list 前端
        ((obj *)p)->next = freeStore;
        freeStore = (obj *)p;
    }
    void allocator::check()
    {
        obj *p = freeStore;
        int count = 0;

        while (p)
        {
            cout << p << endl;
            p = p->next;
            count++;
        }
        cout << count << endl;
    }
    //--------------

    class Foo
    {
    public:
        long L;
        string str;
        static allocator myAlloc;

    public:
        Foo(long l) : L(l) {}

        static void *operator new(size_t size)
        {
            return myAlloc.allocate(size);
        }
        static void operator delete(void *pdead, size_t size)
        {
            return myAlloc.deallocate(pdead, size);
        }
    };
    allocator Foo::myAlloc;

    //-------------
    void test_static_allocator_3()
    {
        cout << "\n\n\ntest_static_allocator().......... \n";

        {
            Foo *p[100];

            cout << "sizeof(Foo)= " << sizeof(Foo) << endl;
            for (int i = 0; i < 6; ++i)
            { //23,任意數, 隨意看看結果
                p[i] = new Foo(i);
                cout << p[i] << ' ' << p[i]->L << endl;
            }
            //Foo::myAlloc.check();

            for (int i = 0; i < 6; ++i)
            {
                delete p[i];
            }
            //Foo::myAlloc.check();
        }
    }
} // namespace jj09

int main()
{

    jj09::test_static_allocator_3();
}