C++封装的用于存放内存块的双向循环列表

　2013-04-25 19:20:12　来源：开发学院　　　

核心提示： C++有许多已经封装好的数据结构，但是当数据不是标准数据时，C++封装的用于存放内存块的双向循环列表，存在很大麻烦，如内存块时

C++有许多已经封装好的数据结构，但是当数据不是标准数据时，存在很大麻烦，如内存块时。
直接进入话题吧：
如题：
结构头文件

#include <stdio.h>
#include <stdlib.h>

#define  uint unsigned int

typedef struct databuf
{
	char *Addr ;
	unsigned int Len ;

	databuf *next;
	databuf *previous;
}databuf,*pdatabuf ;


class NetData
{
public:

	pdatabuf Data ;
	bool Lock ;

	NetData();

	~NetData();

	void Lockdata();
	void UnLockdata();
	void WaitUnLock() ;
    void Entity_entity(pdatabuf Node,char *Addr,uint Len);
    /* first is messy print */
    void Entity_print(pdatabuf Node);
    void PrintList(pdatabuf phead);
    /* Length 1 no data only head */
    int GetLength(pdatabuf phead);
    pdatabuf Before_Null_Node(pdatabuf phead);
    /* Create,return Node add */
    pdatabuf CreateNode(pdatabuf previous,char *Addr,uint Len);
    pdatabuf CreateNode_Head();
    /* Add Node between */
    void AddNode(pdatabuf pNode,pdatabuf pNode2,char *Addr ,uint Len);
    /* Delete next Node */
    bool DeleteNode(pdatabuf pNode);

private:

protected:

};

结构CPP文件

NetData::NetData()
:Lock(0)
{

}
NetData::~NetData()
{

}

void NetData::Lockdata()
{
	printf("Locked\n");
	this->Lock = 1 ;
}
void NetData::UnLockdata()
{
	printf("UnLocked\n");
	this->Lock = 0 ;
}
void NetData::WaitUnLock()
{
	while(this->Lock==1)
	{
		usleep(200000);
	}
	printf("UnLocked\n");
}
void NetData::Entity_entity(pdatabuf Node,char *Addr,uint Len)
{
	Node->Addr = Addr ;
	Node->Len = Len ;
}
pdatabuf NetData::CreateNode_Head()
{
    pdatabuf pNode = (pdatabuf)malloc(sizeof(databuf));
    assert(pNode!=NULL);


    pNode->next = NULL ;
    pNode->previous = pNode;
    return pNode ;
}
/* first is messy print */
void NetData::Entity_print(pdatabuf Node)
{

}
void NetData::PrintList(pdatabuf phead)
{
    pdatabuf p = phead ;
    while(p!=NULL)
    {
        Entity_print(p);
        p = p->next ;
    }
}
/* Length 1 no data only head */
int NetData::GetLength(pdatabuf phead)
{
    pdatabuf p = phead ; int Length=0 ;
    while(p!=NULL)
    {
        Length ++ ;
        p = p->next ;
    }
    return Length ;
}
pdatabuf NetData::Before_Null_Node(pdatabuf phead)
{
    pdatabuf p = phead ;
    while(p->next!=NULL)
    {
        p=p->next ;
    }
    return p ;
}
/* Create,return Node add */
pdatabuf NetData::CreateNode(pdatabuf previous,char *Addr ,uint Len)
{
    pdatabuf pNode = (pdatabuf)malloc(sizeof(databuf));
    assert(pNode!=NULL);
    pNode->next = NULL ;
    pNode->previous = previous ;
    Entity_entity(pNode,Addr,Len);

    return pNode ;
}
/* Add Node between */
void NetData::AddNode(pdatabuf pNode,pdatabuf pNode2,char *Addr,uint Len)
{
    pdatabuf pNew = CreateNode(pNode,Addr,Len);
    pNode->next = pNew ;
    pNew->next = pNode2 ;
    //pNew->previous = pNode ;
}
/* Delete next Node */
bool NetData::DeleteNode(pdatabuf pNode)
{
    pdatabuf pDel = pNode->next ;
    if(pDel==NULL)
    {
        printf(" No Node to Delete ");
        return 0 ;
    }
    pNode->next = pDel->next ;
    pDel->next->previous = pNode ;

    pDel->previous = NULL ;
    pDel->next = NULL ;
    free(pDel->Addr);
    free(pDel);
    return 1 ;
}