嵌入式指针

一般应用在内存池相关的代码中，成功使用嵌入式指针有个前提条件：类A对象的sizeof必须不小于4个字节

工作原理：借用A对象所占用的内存空间中的前4个字节，用来链住这些空闲的内存块；

但是一旦某一块内存被分配出去，那么这个块的前4个字节就不在需要了，此时这4个字节（这里的4字节指的是当前编译器默认的指针类型所占内存大小）可以被类A对象正常使用；

namespace _nmsp4 {
    class myallocator {
    public:
        void *allocate(size_t size) {
            obj *tmplink;
            if (m_FreePosi == nullptr) {
                size_t realsize = m_sTrunkCout * size; //申请m_TrunkCout倍内存
                m_FreePosi = reinterpret_cast<obj *>(malloc(realsize)); //这里的new是系统的new
                tmplink = m_FreePosi;
                //把分配出来的这块内存，彼此要连起来，供后续使用
                for (int i = 0; i< m_sTrunkCout - 1; ++i) {
                    tmplink->next = reinterpret_cast<obj *>(reinterpret_cast<char *>(tmplink) + size);
                    tmplink = tmplink->next;
                }
                tmplink->next = nullptr;
            }
            tmplink = m_FreePosi;
            m_FreePosi = m_FreePosi->next;
            return tmplink;
        }

        void deallocate(void *phead) {
            reinterpret_cast<obj *>(phead)->next = m_FreePosi;
            m_FreePosi = reinterpret_cast<obj *>(phead);
        }


    private:
        struct obj {  
            struct obj *next;  
        };
        obj* m_FreePosi; 
        int m_sTrunkCout = 5;//一次分配多少该类内存
    };

    class A {
    public:
        int m_i;
        int m_j;
        static myallocator myalloc;
        static void *operator new(size_t size) {
            return myalloc.allocate(size);
        }

        static void operator delete(void *phead) {
            myalloc.deallocate(phead);
        }
    };

    myallocator A::myalloc;

    void func() {
        A *mypa[100];
        for (int i = 0; i < 15; ++i) {
            mypa[i] = new A();
            printf("%p\n", mypa[i]);
        }
    }
}

int main()
{
    _nmsp4::func();
    return 0;
}