zList一个块状链表算法可以申请和释放同种对象指针，对于大数据量比直接new少需要差不多一半内存

zList是一个C++的块状内存链表，特点：

1、对于某种类别需要申请大量指针，zList是一个很好的帮手，它能比new少很多内存。

2、它对内存进行整体管理，可以将数据和文件快速互操作

3、和vector对象存储对比，vector存储的对象不能使用其指针，因为vector内容变化时vector存储对象的指针会变化

4、zList也可以当做顺序的数组使用，它有自己的迭代器，可以遍历整个数组

下面是申请5千万个RECT指针对比结果：

zList申请五千万RECT指针内存占用：

直接new五千万RECT指针内存占用：

从对比看节省了724.6M的内存

下面是zList实现代码：

#include "stdafx.h"
#include <set>
#include <map>
#include <string>
#include <vector>
#include <windows.h>
using namespace std;

template <class T>
struct zElem
{
    zElem() { memset(this, 0, sizeof(zElem)); }
    int has() //查找空闲的位置
    {
        return extra < 1024 ? extra : -1;
    }
    bool empty() { return 0 == size; };
    bool full() { return 1024 == size; };
    T *add(int i, const T &r)
    {
        bit[i] = 1;
        R[i] = r;
        size++;
        if (extra == i)//指向下一个位置
        {
            extra++;
            while (extra < 1024)
            {
                if (bit[extra] == 0)break;
                extra++;
            }
        }
        return R + i;
    }
    void remove(T *r)
    {
        int i = (int)(r - R);
        if (i >= 0 && i < 1024)
        {
            bit[i] = 0;
            if (extra > i)extra = (unsigned short)i;
            size--;
        }
    }
    bool in(T *r)
    {
        int i = (int)(r - R);
        return i >= 0 && i < 1024;
    }
    T* get(int i)
    {
        int ind = getInd(i);
        return ind == -1 ? NULL : R + ind;
    }
    int getInd(int i)
    {
        if (i >= 0 && i < extra)return i;
        int k = extra + 1, t = extra;
        while (k < 1024)
        {
            if (bit[k] != 0)
            {
                if (t == i)return k;
                t++;
            }
            k++;
        }
        return -1;
    }
    bool getInd(size_t &ind, size_t &off, size_t n)
    {
        if (ind + n < extra)
        {
            ind += n;
            off = ind;
            return true;
        }
        while (++ind < 1024)
        {
            if (bit[ind] != 0)
            {
                n--;
                off++;
                if (n==0)return true;
            }
        }
        return false;
    }
    unsigned short extra;//指向当前空闲位置
    unsigned short size; //当前已有数据个数
    byte bit[1024];         //标记是否使用
    T R[1024];             //数据存储
};
template <class T>
struct zList
{
    struct iterator
    {
        T* operator *()
        {
            return p ? &p->head[ind]->R[zind] : NULL;
        }
        T* operator ->()
        {
            return p ? &p->head[ind]->R[zind] : NULL;
        }
        iterator& operator ++()
        {
            bool bend = true;
            if (p&&p->head.size() > ind)
            {
                for (; ind < p->head.size(); ind++)
                {
                    zElem<T>*a = p->head[ind];
                    if (zsize + 1 < a->size)
                    {
                        a->getInd(zind,zsize,1);
                        bend = false;
                        break;
                    }
                    zind = zsize = -1;
                }
            }
            if (bend)
            {
                ind = zsize = zind = 0; p = 0;
            }
            return (*this);
        }
        bool operator ==(const iterator &data)const
        {
            return ind == data.ind&&zind == data.zind&&zsize == data.zsize&&p == data.p;
        }
        bool operator !=(const iterator &data)const
        {
            return ind != data.ind||zind != data.zind||zsize != data.zsize||p != data.p;
        }
        explicit operator bool() const 
        {    
            return (!p);
        }
        size_t ind;            //p的位置
        size_t zind;        //zElem中的R位置
        size_t zsize;        //zElem中zind位置所在的次序
        zList *p;            //指向链表的指针
    };
    zList() :size(0),  extra(0) { }
    ~zList() 
    {
        for (auto &a: head)
        {
            delete a;
        }
    }
    T *add(const T &r)
    {
        zElem<T>* e;
        if (extra >= head.size())
        {
            e = new zElem<T>();
            head.push_back(e);
        }
        else
        {
            e = head[extra];
        }
        int i = e->has();
        T *R = e->add(i, r);
        size++;
        while (extra < head.size() && e->full())
        {
            e = head[extra];
            extra++;
        }
        return R;
    }
    void remove(T  *r)
    {
        if (r == NULL)return;
        zElem<T> *rem;
        size_t i = 0;
        for (; i < head.size(); i++)
        {
            rem = head[i];
            if (rem->in(r))
            {
                size--;
                rem->remove(r);
                if (rem->empty())//删除当前节点
                {
                    head.erase(head.begin() + i);
                    if (extra == i)
                    {
                        //往后查找空闲的位置
                        while (extra < head.size())
                        {
                            if (!head[extra]->full())break;
                            extra++;
                        }
                    }
                    delete rem;
                }
                else if(extra > i)
                {
                    extra = i;
                }
                break;
            }
        }
    }
    T* get(int i)
    {
        for (auto &a : head)
        {
            if (i < a->size)
            {
                return a->get(i);
            }
            i -= a->size;
        }
        return NULL;
    }
    void clear()
    {
        for (auto &a : head)
        {
            delete a;
        }
        head.clear();
        size = extra = 0;
    }
    iterator begin()
    {
        iterator it = { 0,0,0,NULL };
        if (head.size() > 0)
        {
            int i = 0;
            for (;it.ind < head.size(); it.ind++)
            {
                zElem<T>*a = head[it.ind];
                if (i < a->size)
                {
                    it.p = this;
                    it.zind = a->getInd(i);
                    break;
                }
                i -= a->size;
            }
        }
        return it;
    }
    iterator end()
    {
        iterator it = {0,0,0,NULL};
        return it;
    }
    size_t size;                //个数
    vector<zElem<T>*> head;        //开头
    size_t extra;                //有空余位置的
};

使用方法如下：

int main()
{
    zList<RECT> z;
    for (int i = 0; i < 50000000; i++)
    {
        //1、申请内存
        RECT r = { rand(), rand(), rand(), rand() };
        RECT *p = z.add(r);
        //2、可以对p进行使用...
        //3、释放内存
        z.remove(p);
    }
    getchar();
    return 0;
}

对zList进行元素遍历，迭代器方法：

int t = 0;
zList<RECT>::iterator its = z.begin();
zList<RECT>::iterator ite = z.end();
for (; its != ite; ++its)
{
    RECT *p = *its;
    t = p->left;
}

对zList进行随机访问遍历，效率没有迭代器高：

int t = 0;
for (int i = 0; i < z.size; i++)
{
    RECT *p = z.get(i);
    t = p->left;
}