_list_.c

汉字在计算机内存放分为两种情况

#include "_List_.h"
#ifndef NULL
#define NULL 0
#endif
/*
* 张向阳 为SIMGUI开发
* 此程序实现一个带有索引的链表基础，可用来支持设计多种类型的链表
* 以及存放你想存放的任何结构构和数据
*/

/*
*获得一个结点内存区的大小
*/
 int    GetListNodeSize(pLIST list,int nodorder)
 {
        if(list == NULL) return -1;
        if(nodorder  < 0 || nodorder >= list->useditems) return -1;
        
        return list->items[nodorder].datasize;
        
 }
 
 /*
 *建立链表
 */
 pLIST  CreateList(int nodnums)
 {
        
        pLIST list = NULL;
    
        if(nodnums <= 0)
        {
                list = (pLIST)malloc(sizeof(LIST));
                list->items   = ( pDATANOD) malloc(ITEMS_DEFNUM * sizeof(DATANOD));
                memset(list->items,0,ITEMS_DEFNUM * sizeof(DATANOD));   
        }
         else
        {
                list = (pLIST)malloc(sizeof(LIST))      ;
                list->items   = (pDATANOD)malloc(nodnums *sizeof(DATANOD));
                memset(list->items,0,nodnums * sizeof(DATANOD));        
        }

        if(list)
        {
                list->itemnums = (nodnums <= 0)?ITEMS_DEFNUM:nodnums;
                list->useditems = 0;
   
        }else return NULL;
    
        return list;

}

/*
*得到LIST中存储的结点总数
*/
int    GetListNodsCount(pLIST list)
 {
        
         if(list == NULL) return -1;
         if(list->items == NULL) return -1;/*validate*/
         if(list->useditems > list->itemnums)return -1;
         return list->useditems;        
 }
 
 /*把数据按照指定序号加入链表*/
 int   AddDataToListByOrder(pLIST list,void *point,int datasize,int order)
 {      
 	/*未实现，没有必要*/
        return 1;
        
 }
 
 /*把指针按照指定序号加入链表*/
 int   AddPointerToListByOrder(pLIST list,void *point,int order)
 {      
        /**/
        return 1;
 }
 
 /*只向链表中增加加一个指针不开辟空间复制*/
 int    AddPointerToList(pLIST list,void *point)
 {
        /**/
        return AddDataToList( list,point, -1); 
 }
 
 /*把数据放入LIST中，采用另外开空间并复制的方式*/
 int   AddDataToList(pLIST list,void *data, int datasize)
 {
        unsigned char *dataspace = NULL;
        
        if(list == NULL || data == NULL) return -1;
         
        if(list->items == NULL)/*null strlist */
        {
                
          list->items = ( pDATANOD) malloc(ITEMS_DEFNUM * sizeof(DATANOD));
          memset(list->items,0,ITEMS_DEFNUM * sizeof(DATANOD)); 
          
          list->itemnums = ITEMS_DEFNUM;
          list->useditems = 0;
        }

        if(list->useditems >= list->itemnums -1)/*not enought space*/
        {
          list->items = (pDATANOD)realloc(list->items,(list->itemnums + ITEMS_DEFNUM) * sizeof(DATANOD));       
          memset(&list->items[list->itemnums - 1],0,sizeof(DATANOD)*ITEMS_DEFNUM );
          list->itemnums += ITEMS_DEFNUM;
        }
        
        if(datasize > 0)
         dataspace = (unsigned char*)malloc(datasize + 1);
        
        if(dataspace)/*这里简单的把开辟的空间交给链表保存，以后考虑增加内存管理功能：开辟的空间不被删掉可复用*/
        {
           memcpy(dataspace,data,datasize);
           dataspace[datasize] = 0;
           list->items[list->useditems].data = dataspace;
           list->items[list->useditems].datasize = datasize;
           list->useditems++;
           return list->useditems - 1;  
        }else if(datasize <= 0)/*增加一个指针型的结点*/
        {
           list->items[list->useditems].data = data;
           list->items[list->useditems].datasize = -1;
           list->useditems++;
           return list->useditems - 1;          
        }
        
        return -1;
        
 }
 
 /*
 *由ORDER获得某个结点
 */
 void * GetListNod(pLIST list,int order)
 {
        if(list == NULL) return NULL;
        if(list->useditems < order)return NULL;
        return  list->items[order].data;
 }
 
 /*
 *由ORDER释放某个结点，但非LIST开辟的内存不会被释放
 */
 BOOL   FreeListNod(pLIST list,int order)
 {
        
        
        
        if(list==NULL) return 0;
        
        
        if(list->useditems <= order)
        return 0;
        
        /*指针存在,而且是链表自己开的空间,若是指针状态的结点则不释放*/
        if(list->items[order].data && list->items[order].datasize > 0)
        {
          free(list->items[order].data);
          list->useditems -- ;
          list->items[order].data = 0;
          list->items[order].datasize = 0;
           
        }else 
        {
	  list->useditems -- ;
	  list->items[order].data = 0;
	}		 
        memcpy(&list->items[order],&list->items[order+ 1],sizeof(DATANOD)*(list->useditems - order));
        memset( &(list->items[list->useditems ]),0,sizeof(DATANOD));
       
        return 1;
 }
 
 /*释放所有由LIST开辟的空间*/
 BOOL   FreeListPrivateSpace(pLIST list)
 {
        if(FreeListNods(list) == 0)
        return 0;
        
        if(list->items)
        {
         free( list->items);/*释放索引表*/
         list->items = NULL;
        }
        
        return 1;
 }
 /*
 *把所有由链表开辟的ITEM空间释放出来
 */
 BOOL   FreeListNods(pLIST list)
 {
        int i;
        if(list == NULL) return 0;
        if(list->useditems > 0)
        for( i = list->useditems -1;i >= 0 ;i--)
        FreeListNod(list,0);
       
        return 1;
 }    
 
 /*
 *删除由CreateList创建的链表
 */
 void   DeleteList(pLIST list)
 {
        if(list == NULL)return;
        FreeListPrivateSpace(list);
        free(list);
 }
 
 /*修改一个结点的内容*/
 BOOL   ModifyListNod(pLIST list,void *data,int datasize,int order)
 {
        if(list == NULL ||data == NULL ) return 0;
        
        if(datasize <= 0||order < 0)return 0;/*无效的引用序号和指针形结点不能处理*/
        if(list->useditems <= order) return 0;
        
        if(list->items[order].data && list->items[order].datasize <= 0)
        return 0;/*指针结点则返回不处理*/
        
        if(list->items[order].data == NULL)/*是空结点就直接使用*/
        {
           list->items[order].data = (void*)malloc(datasize + 1);
           list->items[order].datasize = datasize ;          
        }
        
        if(list->items[order].datasize < datasize)
        {
          free(list->items[order].data);
          list->items[order].data = (void*)malloc(datasize + 1);
          list->items[order].datasize = datasize ;   
          
        }
        
        /*error judge*/
        if(list->items[order].data == NULL )
         return 0;
         
        memset(list->items[order].data,0, list->items[order].datasize + 1);
        memcpy(list->items[order].data,data,datasize);
        
        return 1;
        
 }
 
 /*改变两个结点的位置*/
 BOOL   ChangeTwoNods(pLIST list,int srcnodorder,int dsknodorder)
 {
        DATANOD tempnod;
        if(srcnodorder < 0 || dsknodorder < 0) return 0;
        if(list == NULL)return 0;
    
        if(list->useditems <= srcnodorder ||list->useditems <= srcnodorder )
        return 0;       
        tempnod = list->items[srcnodorder];
        list->items[srcnodorder] = list->items[dsknodorder]; 
        list->items[dsknodorder]  = tempnod;
        return 1;
        
 }
 
  int    GetListNodeOrder(pLIST list,void *item,int itemsize)
  {
        int i;
        void *nod;
        if(list ==NULL || item == NULL || itemsize <= 0) return -1;
        if(list->useditems <= 0)return -1;
         
        for(i = 0;i < GetListNodsCount(list);i++)
        {
                nod = (void *)GetListNod(list,i);
                if(nod)
                if(memcmp(nod,item,itemsize)== 0)
                 return i;
                
        }       
        return -1;
  }