【链表】关于链表的内存池

//自己写的！

#include<iostream>

using namespace std;


typedef struct _DATA_
{

    char szName[20];
    int iAge;
}Data,*pData;

typedef struct _NODE_
{
    Data DataTemp;
    _NODE_* pNext;
}Node,*pNode;


class CList
{
public:
    CList()
    {
        m_pHead = m_pTail = NULL;

    }
    ~CList()
    {

    }

    pNode GetNode(Data DataTemp);
    int GetNodeCount();

    //创建一个结点
    pNode CreateNode(Data DataTemp, CList& FreeListObj);

    //连接
    void LinkNode(pNode pNodeTemp);

    //将结点移回 内存池
    void RemoveNode(pNode pNodeTemp,CList& FreeListObj);

    //从内存池链表中提取结点
    pNode AllocateNode();

    //回收结点
    bool RecycleNode(pNode pNodeTemp);

    bool TravelList();
private:

    pNode m_pHead;
    pNode m_pTail;
    int m_iNodeCount;

};

//创建一个结点，参数为数据的结构体，内存池链表的引用（指针）
pNode CList::CreateNode(Data DataTemp,CList& FreeListObj)
{

    pNode pNodeTemp = NULL;        //申请一个结点的指针

    int iNodeCount = FreeListObj.GetNodeCount();
    //判断内存池链表有无内存结点

    //如果内存池当中存在结点，那么直接从内存池中提取出来（直接用）
    if(iNodeCount > 0)
    {
        pNodeTemp = 
            FreeListObj.AllocateNode();

        cout<<"FreeList"<<endl;
    }

    //如果内存池也是空的，那么申请新的结点
    else
    {
        pNodeTemp = new Node;

        cout<<"New"<<endl;
    }

    //如果申请成功或者从内存池提取成功
    if(pNodeTemp != NULL)
    {
        pNodeTemp->DataTemp = DataTemp;

        pNodeTemp->pNext = NULL;

        return pNodeTemp;

    }
    //如果不成功
    else
    {
        return NULL;
    }    
}




//结点的连接
void CList::LinkNode(pNode pNodeTemp)
{
    //如果头结点是空，说明该结点是第一结点，那么头尾指针如下赋值
    if(m_pHead == NULL)
    {
        m_pHead = m_pTail = pNodeTemp;
    }
    else
    {
        m_pTail->pNext = pNodeTemp;

        m_pTail = pNodeTemp;
    }

    //结点的数量统计
    m_iNodeCount++;
}


//将结点移回 内存池  参数: 结点指针，内存池引用（指针）
//链表中移除的同时，将移除的结点送入内存池中
void CList::RemoveNode(pNode pNodeTemp,CList& FreeListObj)    
{
    //头结点处理: 头结点下移即可
    if(pNodeTemp == m_pHead)
    {
        m_pHead = m_pHead->pNext;
    }
    //尾结点处理: 通过头去找，找到尾结点的前一个结点，
    //将其设置为尾结点并将pNext设置为空
    else if(pNodeTemp = m_pTail)
    {
        pNode pNodePre = m_pHead;
        while(pNodePre->pNext != pNodeTemp)
        {
            pNodePre = pNodePre->pNext;
        }

        pNodePre->pNext = NULL;

        m_pTail = pNodePre;
    }

    //一般情况处理
    else
    {
        pNode pNodePre = m_pHead;
        while(pNodePre->pNext!=pNodeTemp)
        {
            pNodePre = pNodePre->pNext;
        }

        pNodePre->pNext = pNodeTemp->pNext;
    }

    m_iNodeCount--;

    if(m_iNodeCount == 0)
    {
        m_pTail = NULL;
    }

    //回收结点
    //链表中移除的同时，将移除的结点送入内存池中
    if(!FreeListObj.RecycleNode(pNodeTemp))
    {
        cout<<"Error"<<endl;
    }

}

int CList::GetNodeCount()
{
    if(m_pHead==NULL)
    {
        return 0;
    }

    else
    {
        return m_iNodeCount;
    }
}

pNode CList::GetNode(Data DataTemp)
{
    pNode pNodeTemp = m_pHead;
    while(pNodeTemp!=NULL)
    {
        if(strcmp(
            pNodeTemp->DataTemp.szName,
            DataTemp.szName)==0)
        {
            return pNodeTemp;
        }
    }

    return NULL;
}

//从内存池链表中提取一个结点
//前提:内存池中有结点，这个前面会判断，所以这里没问题
pNode CList::AllocateNode()
{
    if(m_pHead == m_pTail)
    {

        m_pTail = NULL;
    }
    pNode pNodeTemp = m_pHead;

    m_pHead = m_pHead->pNext;

    pNodeTemp->pNext = NULL;


    m_iNodeCount--;

    return pNodeTemp;
}

//回收结点到内存池
//直接插入到内存池，结束战斗
bool CList::RecycleNode(pNode pNodeTemp)
{
    if(pNodeTemp!=NULL)
    {
        pNodeTemp->pNext = m_pHead;

        m_pHead = pNodeTemp;

        m_iNodeCount++;

        return true;
    }

    return false;

}



bool CList::TravelList()
{
    if(m_pHead == NULL)
    {
        return false;
    }

    pNode pNodeTemp = m_pHead;

    while(pNodeTemp!=NULL)
    {
        cout<<pNodeTemp->DataTemp.szName<<"  "
            <<pNodeTemp->DataTemp.iAge<<endl;

        pNodeTemp = pNodeTemp->pNext;
    }
    return true;
}


int main()
{

    
    CList CurrentList;

    CList FreeList;

    int iNum = 0;

    Data DataTemp = {0};

    pNode pNodeTemp = NULL;

    cout<<"Input Num"<<endl;
    cin>>iNum;

    while(iNum)
    {
        cout<<"Input Name Age"<<endl;

        cin>>DataTemp.szName;
        cin>>DataTemp.iAge;

        pNodeTemp = CurrentList.CreateNode(DataTemp,FreeList);

        CurrentList.LinkNode(pNodeTemp);

        iNum--;
    }
    CurrentList.TravelList();


    bool bOk = true;
    int iMethod;

    while(bOk)
    {
        cout<<"1.  Insert"<<endl;
        cout<<"2.  Remove"<<endl;
        cout<<"30.  Exit"<<endl;
        
        cin>>iMethod;

        switch(iMethod)
        {
        case 1:
            cout<<"Input Name Age"<<endl;

            cin>>DataTemp.szName;
            cin>>DataTemp.iAge;

            pNodeTemp = CurrentList.CreateNode(DataTemp,FreeList);
            CurrentList.LinkNode(pNodeTemp);

            CurrentList.TravelList();

            break;
        case 2:
            cout<<"Input DataTemp To Remove"<<endl;

            cin>>DataTemp.szName;
            cin>>DataTemp.iAge;

            pNodeTemp = CurrentList.GetNode(DataTemp);

            CurrentList.RemoveNode(pNodeTemp,FreeList);
            CurrentList.TravelList();
            break;

        case 30:
            bOk = false;
            break;
        }

    }



    return 0;

}

上面的代码有BUG

下面是debug之后的代码

#include<iostream>
#include<string.h>
using namespace std;


typedef struct _DATA_
{

    char szName[20];
    int iAge;
}Data,*pData;

typedef struct _NODE_
{
    Data DataTemp;
    _NODE_* pNext;
}Node,*pNode;


class CList
{
public:
    CList()
    {
        m_pHead = m_pTail = NULL;

    }
    ~CList()
    {

    }

    pNode GetNode(Data DataTemp);
    int GetNodeCount();

    //创建一个结点
    pNode CreateNode(Data DataTemp, CList& FreeListObj);

    //连接
    void LinkNode(pNode pNodeTemp);

    //将结点移回 内存池
    void RemoveNode(pNode pNodeTemp,CList& FreeListObj);

    //从内存池链表中提取结点
    pNode AllocateNode();

    //回收结点
    bool RecycleNode(pNode pNodeTemp);

    bool TravelList();
private:

    pNode m_pHead;
    pNode m_pTail;
    int m_iNodeCount;

};

//创建一个结点，参数为数据的结构体，内存池链表的引用（指针）
pNode CList::CreateNode(Data DataTemp,CList& FreeListObj)
{

    pNode pNodeTemp = NULL;        //申请一个结点的指针

    int iNodeCount = FreeListObj.GetNodeCount();
    //判断内存池链表有无内存结点

    //如果内存池当中存在结点，那么直接从内存池中提取出来（直接用）
    if(iNodeCount > 0)
    {
        pNodeTemp = 
            FreeListObj.AllocateNode();

        cout<<"FreeList"<<endl;
    }

    //如果内存池也是空的，那么申请新的结点
    else
    {
        pNodeTemp = new Node;

        cout<<"New"<<endl;
    }

    //如果申请成功或者从内存池提取成功
    if(pNodeTemp != NULL)
    {
        pNodeTemp->DataTemp = DataTemp;

        pNodeTemp->pNext = NULL;

        return pNodeTemp;

    }
    //如果不成功
    else
    {
        return NULL;
    }    
}




//结点的连接
void CList::LinkNode(pNode pNodeTemp)
{
    //如果头结点是空，说明该结点是第一结点，那么头尾指针如下赋值
    if(m_pHead == NULL)
    {
        m_pHead = m_pTail = pNodeTemp;
    }
    else
    {
        m_pTail->pNext = pNodeTemp;

        m_pTail = pNodeTemp;
    }

    //结点的数量统计
    m_iNodeCount++;
}


//将结点移回 内存池  参数: 结点指针，内存池引用（指针）
//链表中移除的同时，将移除的结点送入内存池中
void CList::RemoveNode(pNode pNodeTemp,CList& FreeListObj)    
{
    //头结点处理: 头结点下移即可
    if(pNodeTemp == m_pHead)
    {
        m_pHead = m_pHead->pNext;
    }
    //尾结点处理: 通过头去找，找到尾结点的前一个结点，
    //将其设置为尾结点并将pNext设置为空
    else if(pNodeTemp == m_pTail)
    {
        pNode pNodePre = m_pHead;
        while(pNodePre->pNext != pNodeTemp)
        {
            pNodePre = pNodePre->pNext;
        }

        pNodePre->pNext = NULL;

        m_pTail = pNodePre;
    }

    //一般情况处理
    else
    {
        pNode pNodePre = m_pHead;
        while(pNodePre->pNext!=pNodeTemp)
        {
            pNodePre = pNodePre->pNext;
        }

        pNodePre->pNext = pNodeTemp->pNext;
    }

    m_iNodeCount--;

    if(m_iNodeCount == 0)
    {
        m_pTail = NULL;
    }

    //回收结点
    //链表中移除的同时，将移除的结点送入内存池中
    if(!FreeListObj.RecycleNode(pNodeTemp))
    {
        cout<<"Error"<<endl;
    }

}

int CList::GetNodeCount()
{
    if(m_pHead==NULL)
    {
        return 0;
    }

    else
    {
        return m_iNodeCount;
    }
}

pNode CList::GetNode(Data DataTemp)
{
    pNode pNodeTemp = m_pHead;
    while(pNodeTemp!=NULL)
    {
        if(strcmp(
            pNodeTemp->DataTemp.szName,
            DataTemp.szName)==0)
        {
            return pNodeTemp;
        }
        pNodeTemp = pNodeTemp->pNext;
    }

    return NULL;
}

//从内存池链表中提取一个结点
//前提:内存池中有结点，这个前面会判断，所以这里没问题
pNode CList::AllocateNode()
{
    if(m_pHead == m_pTail)
    {

        m_pTail = NULL;
    }
    pNode pNodeTemp = m_pHead;

    m_pHead = m_pHead->pNext;

    pNodeTemp->pNext = NULL;


    m_iNodeCount--;

    return pNodeTemp;
}

//回收结点到内存池
//直接插入到内存池，结束战斗
bool CList::RecycleNode(pNode pNodeTemp)
{
    if(pNodeTemp!=NULL)
    {
        pNodeTemp->pNext = m_pHead;

        m_pHead = pNodeTemp;

        m_iNodeCount++;

        return true;
    }

    return false;

}



bool CList::TravelList()
{
    if(m_pHead == NULL)
    {
        return false;
    }

    pNode pNodeTemp = m_pHead;

    while(pNodeTemp!=NULL)
    {
        cout<<pNodeTemp->DataTemp.szName<<"  "
            <<pNodeTemp->DataTemp.iAge<<endl;

        pNodeTemp = pNodeTemp->pNext;
    }
    return true;
}


int main()
{

    
    CList CurrentList;

    CList FreeList;

    int iNum = 0;

    Data DataTemp = {0};

    pNode pNodeTemp = NULL;

    cout<<"Input Num"<<endl;
    cin>>iNum;

    while(iNum)
    {
        cout<<"Input Name Age"<<endl;

        cin>>DataTemp.szName;
        cin>>DataTemp.iAge;

        pNodeTemp = CurrentList.CreateNode(DataTemp,FreeList);

        CurrentList.LinkNode(pNodeTemp);

        iNum--;
    }
    CurrentList.TravelList();


    bool bOk = true;
    int iMethod;

    while(bOk)
    {
        cout<<"1.  Insert"<<endl;
        cout<<"2.  Remove"<<endl;
        cout<<"30.  Exit"<<endl;
        
        cin>>iMethod;

        switch(iMethod)
        {
        case 1:
            cout<<"Input Name Age"<<endl;

            cin>>DataTemp.szName;
            cin>>DataTemp.iAge;

            pNodeTemp = CurrentList.CreateNode(DataTemp,FreeList);
            CurrentList.LinkNode(pNodeTemp);

            CurrentList.TravelList();

            break;
        case 2:
            cout<<"Input DataTemp To Remove"<<endl;

            cin>>DataTemp.szName;
            cin>>DataTemp.iAge;

            pNodeTemp = CurrentList.GetNode(DataTemp);

            if(pNodeTemp == NULL)
            {
                cout<<"No Data."<<endl;
            }
            else
            {
                CurrentList.RemoveNode(pNodeTemp,FreeList);
            }
            CurrentList.TravelList();
            break;

        case 30:
            bOk = false;
            break;
        }

    }



    return 0;

}

以下文章留着看

http://blog.csdn.net/nanjunxiao/article/details/8970396

http://blog.csdn.net/networkwx/article/details/6326275

http://www.cnblogs.com/bangerlee/archive/2011/08/31/2161421.html

内存池对于长时间运行的程序特别有用，可以减少内存碎片，提高效率，避免内存益处等众多好处，网上流传的内存池模型有很多种大致分为固定快大小的链表（本文采用的），这种内存池的优点是速度快，碎片少，缺点是灵活性不足，但对于搞定能的服务器端程序而言很多的数据都是已知的，为了追求速度这种牺牲是可以理解的；另外还有基于大块内存的可变长度内存分配方法，优点是对于字符串类似的应用提供了很好的解决方法，缺点是要自己管理碎片，相当于在系统的内存管理之上再构建一个内存管理，同样有查找合适内存快的开销；

本文采用的是固定内存快的内存池，当所要求分配的内存大于快的大小时则直接交由系统分配，以后才会采用其他的方式写出内存池，采取性能最优原则，另外对于多线程还需要系统锁，也会增加开销，如何权衡需要多种方案对比才能得出结论。

源代码如下，经测试直接分配达到测试的循环需求需要500毫秒左右，采用内存池在100毫秒左右


#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "testStruct.h"
#define BLKSIZ 80 //回收块的大小
#define STKSIZ 4000 //每块内存大小

struct BLOCK
{
char *link;
char data[BLKSIZ];
};
static struct BLOCK * heap;
static struct BLOCK * top_of_heap;
static struct BLOCK * btm_of_heap;
int kint=0;
/*初始化*/
void Init_heap()
{
unsigned blk;
struct BLOCK *ptr;
heap=(struct BLOCK *)malloc(BLKSIZ);//第一个快
btm_of_heap=heap;
ptr=heap;
for(blk=0;blk<500;blk++)
{
   ptr->link=(struct BLOCK *)malloc(BLKSIZ);
   ptr=ptr->link;
}
ptr->link=NULL;
top_of_heap=ptr;
}

/*根据系统需求增加新的块*/
void expendMem()
{

unsigned blk;
struct BLOCK *ptr;
heap=(struct BLOCK *)malloc(BLKSIZ);//第一个快
top_of_heap=heap;
ptr=heap;
for(blk=0;blk<49;blk++)
{
   ptr->link=(struct BLOCK *)malloc(BLKSIZ);
   ptr=ptr->link;
}
ptr->link=NULL;
top_of_heap=ptr;
kint++;
printf(" %i ",kint);
}

/*释放一个区域的内存*/
void My_Free(struct BLOCK *ptr)
{
if(ptr>=btm_of_heap)
{
   if(ptr<top_of_heap)
   {
    ptr->link=heap;
    heap=ptr;
    return;
   }
   else
     {
    free(ptr);
    //printf("释放"); 
    return;
   }
}
puts("
Attempt to free blocks ");
}

/*申请一块内存*/

void *Allocate(unsigned bytes)
{
void *ptr;
if(bytes<=BLKSIZ)
{
   if(heap!=NULL)
   {
    ptr=heap;
    heap=heap->link;
    return ptr;
   }
   else
   {
    expendMem();
   }
}
if(ptr=malloc(bytes))
{
   return ptr;
}
puts(" memory");
}

/*主函数*/
int main()
{
int j=0;
int lint=0;
struct BLOCK *p[1000];
    char User[20] = {"xiaoming"} ;
   // char Password[20] = "123456";

DWORD last,current;
last=GetTickCount();
Init_heap();
for(j=0;j<500;j++)
{
   int i;
   for(i=0;i<1000;i++)
   {
    p[i]=Allocate(20);// New(struct Login,1);
   
    strcpy(p[i]->data,User);
//   strcpy(p->Password,Password);
   }
   for(i=0;i<1000;i++)
    My_Free(p[i]);
}
heap=btm_of_heap;
while(heap->link!=NULL)
{/*循环输出内存管理链表中的序列号，看看有没有断链*/
   lint++;
   printf("l:%i ",lint);
   heap=heap->link;
}
current=GetTickCount();
printf("总共耗时 %d",current-last);

}