AMPS:单向链表源码解读

最新推荐文章于 2013-01-27 22:54:27 发布
最新推荐文章于 2013-01-27 22:54:27 发布
阅读量2.7k 收藏
点赞数 2
分类专栏： C/C++ 消息中间件 AMPS源码解读
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dyx1024/article/details/8519853
版权

  像单向链表、双向链表、堆、栈等这些基本的数据结构在大型软件中均有很广泛的使用，所以今天看一下AMPS中单向链表的操作函数库，其定义了单向链表的非常多的操作API，且提供了回调函数接口，从而使链表结构用于不同类型的结点，且可以使用户自定义的函数来实现链表排序、结点操作。所以这部分的代码可以做为常用的工具代码，可以在其他项目中广泛应用。

 先看看AMPS提供的单链表操作接口有哪些？如下,由函数名称就可以看出，有非常丰富的函数。

 

最后，看一下单向链表的实现源代码：

AMPS_LinkList.h

#ifndef __HEADER_AMPS_LINKLIST_H__
#define __HEADER_AMPS_LINKLIST_H__

#ifdef __cplusplus
extern "C"
{
#endif

#include "AMPS_API.h"
#include "AMPS_Defines.h"


typedef struct _AMPSDList    t_AMPSDList;

struct _AMPSSList
{
	void*			pvData;
	t_AMPSSList*	poAMPSSListNext;
	t_AMPSSList*	poAMPSSListPrev;
};


int SList_InsertSortedPrepend(void** r_ppvList, void* r_pvKey, void* r_pvData, AMPS_LListCompareCallback r_pfAMPS_LListCompareCallback);
int SList_InsertSortedAppend(void** r_ppvList, void* r_pvKey, void* r_pvData, AMPS_LListCompareCallback r_pfAMPS_LListCompareCallback);
void SList_SortPrepend(void** r_ppvList, AMPS_LListCompareCallback r_pfAMPS_LListCompareCallback);
void SList_SortAppend(void** r_ppvList, AMPS_LListCompareCallback r_pfAMPS_LListCompareCallback);
int SList_Traverse(void* r_ppvList, AMPS_LListProcessCallback r_pfAMPS_LListProcessCallback, void* r_pvArg);
int SList_Copy(void** r_ppvDest, void* r_pvSrc, AMPS_LListCompareCallback r_pfAMPS_LListCompareCallback, AMPS_LListCloneCallback r_pfAMPS_LListCloneCallback);
int SList_RemoveKey(void** r_ppvList, void* r_pvData, AMPS_LListCompareCallback r_pfAMPS_LListCompareCallback);
void* SList_FindData (void* r_pvList, void* r_pvData);
void* SList_GetNextNode(void* r_pvList);
void* SList_GetNodeData(void* r_pvNode);
void SList_AppendGivenNode(void** r_ppvList, void* r_pvSListNode);
void SList_PrependGivenNode(void** r_ppvList, void* r_pvGivenNode, void* r_pvNewNode);
t_AMPSSList* SList_Prepend(t_AMPSSList** r_ppoSList, void* r_pvData);
t_AMPSSList* SList_AppendEx(t_AMPSSList** r_ppoSList, void* r_pvData);
int SList_Append(void** r_ppvList, void* r_pvData, AMPS_LListCompareCallback r_pfAMPS_LListCompareCallback);
t_AMPSSList* SList_Last(t_AMPSSList* r_poSList);
void* SList_Alloc(void* r_pvData);
t_AMPSSList* SList_Search(t_AMPSSList* r_poSList, AMPS_LListCompareLinkDataCallback r_pfAMPS_LListCompareCallback, void* r_pvSrcData);
t_AMPSSList* SList_Find (t_AMPSSList* r_poSList, t_AMPSSList* r_poSListNode);
int SList_Remove(t_AMPSSList** r_ppoSList, t_AMPSSList* r_poSListNode, AMPS_LListFreeLinkDataCallback r_pfAMPS_LListFreeLinkDataCallback);
int SList_Free(t_AMPSSList** r_ppoSList, AMPS_LListFreeLinkDataCallback r_pfAMPS_LListFreeLinkDataCallback);
int SList_FreeEx(t_AMPSSList** r_ppoSList, AMPS_LListProcessCallback r_pfAMPS_LListProcessCallback, void* r_pvData);
unsigned int SList_Count(const t_AMPSSList* r_cpoSList);
int SList_Concat(t_AMPSSList** r_ppoSListSrc, t_AMPSSList* r_poSListDst);
#ifdef __cplusplus

}
#endif

#endif /* __HEADER_AMPS_LINKLIST_H__ */

AMPS_LinkList.c 

/*****************************************************************
文件名称: AMPS_LinkList.c
功能描述: 链表操作API函数(单向链表和双向链表)

*****************************************************************/

#include "AMPS_LinkList.h"
#include "AMPS_MemMgt.h"

/*****************************************************************
函数名称: SList_Append
功能描述: 在链表后追加结点
入参::
      void **list 原链表
      void* pvData 待追加的结点
      AMPS_LListCompareCallback compare 链表比较回调，此函数中没有使用

出参:
      void **list 追加后的链表
返回值:
      int

*****************************************************************/
int SList_Append(void **list, void* pvData, AMPS_LListCompareCallback compare)
{
	t_AMPSSList** slist = (t_AMPSSList**)list;

	{
		t_AMPSSList *new_list = NULL;  // pointer to newly created node
		t_AMPSSList *last = NULL;      // pointer to last node of link list 
		t_AMPSSList *list_ptr = *slist;

        /*在链表中分配新结点所要使用的内存空间*/
		new_list = SList_Alloc(pvData);
		if (NULL == new_list)
		{
			return -1;
		}
		if (list_ptr)
		{
            /*找到当前链表结束*/
			last = SList_Last(list_ptr);
			if (NULL == last)
			{
				free(new_list);
				return -1;
			}

            /*将待追加的结点连接到当前链表结尾*/
			last->poAMPSSListNext = new_list;
	 		new_list->poAMPSSListPrev = last;
		}
		else
		{
            /*如果当前链表为空，则待追加结点做为链表头结点*/
			*slist = new_list;
		}
		return 0;
	}
}

/*****************************************************************
函数名称: SList_InsertSortedPrepend
功能描述: 在有序链表中前向插入新结点
入参::
      void **list 原链表
      void* key 未使用
      void* pvData 待插入结点
      AMPS_LListCompareCallback compare 结点比较回调函数，由调用者实现

出参:
      void **list 追加后的链表
返回值:
      int

*****************************************************************/
int SList_InsertSortedPrepend(void **list, void* key, void* pvData, AMPS_LListCompareCallback compare)
{

	t_AMPSSList** slist = (t_AMPSSList**)list;

    /*判断要添加的结点是否已在链表中存在，已存在，直接返回成功*/
	if(NULL != SList_FindData(*slist,pvData) )
	{
	   printf("slist_insert_sorted: node already found in list\n");
       return 0;
	}

	{
		t_AMPSSList *new_node = NULL;  // pointer to newly created node
		t_AMPSSList *list_ptr = *slist, *curr;
		new_node = SList_Alloc(pvData);
		if (NULL == new_node)
		{
			return -1;
		}
		
		if (list_ptr)
		{
            /*遍历链表*/
			while (list_ptr)
			{
				/*如果当前链表结点不大于待插入结点，将其插入此结点之后*/
                if (AMPS_LLIST_KEY_IS_GREATER != compare(list_ptr->pvData, pvData))
				{
                   break;
				}
				curr = list_ptr;
                list_ptr = list_ptr->poAMPSSListNext;
			}
            
			if(!list_ptr)
			{
                /*如果已到链表结尾，刚将新结点插入到最后*/
                SList_AppendGivenNode((void **)&curr, (void*)new_node);
			}
			else 
			{
                /*未到结尾已找到插入位置，刚插入到链表中间*/
				SList_PrependGivenNode(list, (void*)list_ptr,(void*)new_node);
			}
		}
		else
		{
			*slist = new_node;
		}
		return 0;
	}
}

/*****************************************************************
函数名称: SList_InsertSortedAppend
功能描述: 在递增的有序链表中插入新结点
入参::
      void **list 原链表
      void* key 未使用
      void* pvData 待插入结点
      AMPS_LListCompareCallback compare 结点比较回调函数，由调用者实现

出参:
      void **list 追加后的链表
返回值:
      int

*****************************************************************/
int SList_InsertSortedAppend(void **list, void* key, void* pvData, AMPS_LListCompareCallback compare)
{

	t_AMPSSList** slist = (t_AMPSSList**)list;
    
	if(NULL != SList_FindData(*slist,pvData) )
	{
	   printf("slist_insert_sorted: node already found in list\n");
       return 0;
	}

	{
		t_AMPSSList *new_node = NULL;  // pointer to newly created node
		t_AMPSSList *list_ptr = *slist, *curr;
		new_node = SList_Alloc(pvData);
		if (NULL == new_node)
		{
			return -1;
		}
		
		if (list_ptr)
		{
			while (list_ptr)
			{
			    if (AMPS_LLIST_KEY_IS_SMALLER == compare(list_ptr->pvData, pvData))
				{
                   break;
				}
				curr = list_ptr;
                list_ptr = list_ptr->poAMPSSListNext;
			}
			if(!list_ptr)
			{
                SList_AppendGivenNode((void **)&curr, (void*)new_node);
			}
			else 
			{
                SList_PrependGivenNode(list, (void*)list_ptr,(void*)new_node);
			}
		}
		else
		{
			*slist = new_node;
		}
		return 0;
	}
}

/*****************************************************************
函数名称: SList_SortPrepend
功能描述: 链表排序
入参::
      void **list 原链表
      AMPS_LListCompareCallback compare 结点比较回调函数，由调用者实现

出参:
      void **list 排序后的链表
返回值:
      void

*****************************************************************/
void SList_SortPrepend(void** list,AMPS_LListCompareCallback compare)
{
  t_AMPSSList** slist = (t_AMPSSList**)list;
  t_AMPSSList *list_ptr = *slist;

    if (list_ptr)
	{
		while (list_ptr)
		{	
		   t_AMPSSList* poAMPSSListNext = list_ptr->poAMPSSListNext;
           
           /*保存待删除结点的内容*/
           void* pvData = list_ptr->pvData;
           
           /*从链表中删除结点*/
		   SList_Remove(slist,list_ptr,NULL);
           
           /*将已删除结点的内容插入到排序后的链表*/
		   SList_InsertSortedPrepend((void **)slist,NULL,pvData,compare); 
		   list_ptr = poAMPSSListNext; 
		}
		
	}
}

/*****************************************************************
函数名称: SList_SortAppend
功能描述: 链表排序(严格递增)
入参::
      void **list 原链表
      AMPS_LListCompareCallback compare 结点比较回调函数，由调用者实现

出参:
      void **list 排序后的链表
返回值:
      void

*****************************************************************/
void SList_SortAppend(void** list,AMPS_LListCompareCallback compare)
{
  t_AMPSSList** slist = (t_AMPSSList**)list;
  t_AMPSSList *list_ptr = SList_Last(*slist);

    if (list_ptr)
	{
		while (list_ptr)
		{	
		   t_AMPSSList* poAMPSSListPrev = list_ptr->poAMPSSListPrev;
           void* pvData = list_ptr->pvData;
		   SList_Remove(slist,list_ptr,NULL);
           SList_InsertSortedAppend((void **)slist,NULL,pvData,compare);
           list_ptr = poAMPSSListPrev; 
		}
	}
}

/*****************************************************************
函数名称: SList_Traverse
功能描述: 遍历并通过用户自定义的回调函数处理各结点
入参::
      void **list 原链表
      AMPS_LListProcessCallback compare 结点处理回调函数，由调用者实现
      void* arg  回调函数参数

出参:
      void **list 处理之后的链表
返回值:
      int

*****************************************************************/
int SList_Traverse(void* list,AMPS_LListProcessCallback func,void* arg)
{
   t_AMPSSList *slist = (t_AMPSSList*)list,*tempList = NULL;
   
   if(!slist)
   {
	  return 0;
   }

   for(tempList = slist;tempList;tempList = tempList->poAMPSSListNext)
   {
      func(tempList->pvData,arg);    
   }
   
   return 0; 
}

/*****************************************************************
函数名称: SList_Traverse
功能描述: 复制一份原链表，在复制过程中可以处理各结点，以实现对于不同类型
          结点的操作。
入参::
      void** dest 目标链表
      void* src   源链表
      AMPS_LListCompareCallback compare  结点比较回调，没有使用
      AMPS_LListCloneCallback clone 结点处理函数回调

出参:
      void** dest 处理之后的链表
返回值:
      int

*****************************************************************/
int SList_Copy(void** dest,void* src,AMPS_LListCompareCallback compare,AMPS_LListCloneCallback clone)
{

   t_AMPSSList* srcList = (t_AMPSSList*)src;
   void* pvData;

   if(!srcList)
   {
	  return 0;
   }

   for(;srcList;srcList = srcList->poAMPSSListNext)
   {
     /*逐一处理各结点，比如结点数据为char*，则需要strcpy，如为int，直接赋值*/
     pvData = clone(srcList->pvData);

     /*将处理后的结点插入目标链表，最后，两链表长度相同，但结点内容可以不同*/
	 SList_Append(dest,pvData,NULL);
   }
   
   return 0;
}


/*****************************************************************
函数名称: SList_AppendEx
功能描述: 向链表后追加结点，返回最终链表
入参::
      t_AMPSSList** list 原链表
      void* pvData       待追加结点

出参:
      NA
返回值:
      t_AMPSSList*  处理之后的链表

*****************************************************************/
t_AMPSSList* SList_AppendEx(t_AMPSSList** list, void* pvData)
{
	t_AMPSSList** slist = (t_AMPSSList**)list;
	t_AMPSSList* new_list = NULL;  // pointer to newly created node
	t_AMPSSList* last = NULL;      // pointer to last node of link list 
	t_AMPSSList* list_ptr = *slist;
	
	new_list = SList_Alloc(pvData);
	if(NULL == new_list)
	{
		return NULL;
	}
	if(list_ptr)
	{
		last = SList_Last(list_ptr);
		if(NULL == last)
		{
			free(new_list);
			return NULL;
		}
		last->poAMPSSListNext = new_list;
		new_list->poAMPSSListPrev = last;
	}
	else
	{
		*slist = new_list;
	}
	return new_list;
}

/*****************************************************************
函数名称: SList_Prepend
功能描述: 向链表头追加结点，返回最终链表
入参::
      t_AMPSSList** list 原链表
      void* pvData       待追加结点

出参:
      NA
返回值:
      t_AMPSSList*  处理之后的链表

*****************************************************************/
t_AMPSSList* SList_Prepend(t_AMPSSList **list, void* pvData)
{
    t_AMPSSList *new_list = NULL;
    t_AMPSSList *list_ptr = *list;

    new_list = (t_AMPSSList*)SList_Alloc(pvData);
    if (NULL == new_list)
    {
        return NULL;
    }
    new_list->poAMPSSListNext = list_ptr;
    new_list->poAMPSSListPrev = NULL;

    if (list_ptr)
    {
        list_ptr->poAMPSSListPrev = new_list;  
    }

    *list = new_list;

    return new_list;
}

/*****************************************************************
函数名称: SList_Last
功能描述: 查找链表结尾
入参::
      t_AMPSSList** list 原链表

出参:
      NA
返回值:
      t_AMPSSList*  处理之后的链表

*****************************************************************/
t_AMPSSList* SList_Last(t_AMPSSList *list)
{/*
    if (NULL != list)
    {	*/
    if (list)
    {
        while (list->poAMPSSListNext)
        {
            list = list->poAMPSSListNext;
        }
    }
    //}
    return list;
}

/*****************************************************************
函数名称: SList_Alloc
功能描述: 分配新的链表结点，并赋值
入参::
      void* pvData 结点

出参:
      NA
返回值:
      void*  处理之后的链表

*****************************************************************/
void* SList_Alloc(void* pvData)
{
    t_AMPSSList* new_list = NULL;
   	new_list = AMPS_InternalMalloc(sizeof(t_AMPSSList));
	if(NULL == new_list)
	{
		printf("=>>>>>>>>>>>>>>>>>>>>> malloc failed.\n\n\n\n\n\n\n\n");
		return NULL;
	}
	new_list->pvData = pvData;
	new_list->poAMPSSListNext = NULL;
	new_list->poAMPSSListPrev = NULL;
    return (void*)new_list;
}

/*****************************************************************
函数名称: SList_RemoveKey
功能描述: 删除链表中的指定结点
入参::
      void** list 原链表
      void* pvData 待删除结点
      AMPS_LListCompareCallback compare 结点比较回调函数

出参:
      void** list
返回值:
      int

*****************************************************************/
int SList_RemoveKey(void** list,void* pvData,AMPS_LListCompareCallback compare)
{
	t_AMPSSList** slist = (t_AMPSSList**)list;

    t_AMPSSList *list_ptr = (t_AMPSSList*)*slist;
    while (list_ptr)
    {
        /*使用用户自定义的回调函数比较结点，相等，则从链表中删除*/
        if (AMPS_LLIST_KEYS_ARE_EQUAL == compare(list_ptr->pvData,pvData))
        {
            SList_Remove(slist, (void*)list_ptr, NULL);
            break;
        }
        list_ptr = list_ptr->poAMPSSListNext;
    }
    return 0;
}

/*****************************************************************
函数名称: SList_Search
功能描述: 在链表中查找符合条件的结点
入参::
      t_AMPSSList *list 原链表
      AMPS_LListCompareCallback func_ptr 结点查找回调函数
      void *src_data 指定的查找条件

出参:
      void** list
返回值:
      t_AMPSSList* 找到的结点指针

*****************************************************************/
t_AMPSSList* SList_Search (t_AMPSSList *list, AMPS_LListCompareLinkDataCallback func_ptr, void *src_data)
{
    while (list)
    {
        if (!func_ptr(src_data, list->pvData))
        {
            break;
        }
        list = list->poAMPSSListNext;
    }
    return list;
}

/*****************************************************************
函数名称: SList_Find
功能描述: 在链表中查找指定的结点
入参::
      t_AMPSSList *list 原链表
      t_AMPSSList *node 指定的结点

出参:
      t_AMPSSList *list
返回值:
      t_AMPSSList* 找到的结点指针

*****************************************************************/
t_AMPSSList* SList_Find (t_AMPSSList *list, t_AMPSSList *node)
{
    while (list)
    {
        if (list == node)
        {
            return list;
        }
        list = list->poAMPSSListNext;
    }
    return NULL;
}

/*****************************************************************
函数名称: SList_Find
功能描述: 在链表中查找指定的结点内容
入参::
      void *list 原链表
      void *pvData 指定的结点内容

出参:
      t_AMPSSList *list
返回值:
      void* 找到的结点指针

*****************************************************************/
void* SList_FindData (void *list, void *pvData)
{
	t_AMPSSList *slist = (t_AMPSSList*)list;
	while (slist)
	{
		if (slist->pvData == pvData)
		{
			return slist;
		}
		slist = slist->poAMPSSListNext;
	}
	return NULL;
}

/*****************************************************************
函数名称: SList_Free
功能描述: 释放链表
入参::
      void *list 原链表
      AMPS_LListFreeLinkDataCallback func_ptr 结点处理回调函数，如果结点
      的内存需要显式释放，使用此函数达到目的。

出参:
      t_AMPSSList *list
返回值:
      int

*****************************************************************/
int SList_Free(t_AMPSSList **list, AMPS_LListFreeLinkDataCallback func_ptr)
{
    t_AMPSSList *curr = NULL;  // pointer to current node 
    t_AMPSSList *poAMPSSListPrev = NULL;  // pointer to previous node 

    curr = *list;
    while (curr)
    {
        poAMPSSListPrev = curr;
        curr = (t_AMPSSList*)curr->poAMPSSListNext;
        if (func_ptr)
        {
            /*释放结点*/
            if (func_ptr(&(poAMPSSListPrev->pvData)))
            {
                return AMPS_ERROR_FAILURE;
            }
        }
        /*if (poAMPSSListPrev->pvData)
        {
            AMPS_InternalFree(poAMPSSListPrev->pvData);
        }*/
        AMPS_InternalFree(poAMPSSListPrev);
    }

    *list = NULL;

    return AMPS_SUCCESS;
}

/*****************************************************************
函数名称: SList_FreeEx
功能描述: 释放链表
入参::
      void *list 原链表
      AMPS_LListFreeLinkDataCallback func_ptr 结点处理回调函数，如果结点
      的内存需要显式释放，使用此函数达到目的。
      void* r_pvData 回调函数入参，通过它可以进行在释放前的一些结点操作

出参:
      t_AMPSSList *list
返回值:
      int

*****************************************************************/
int SList_FreeEx(t_AMPSSList **list, AMPS_LListProcessCallback func_ptr, void* r_pvData)
{
	t_AMPSSList *curr = NULL;  // pointer to current node 
	t_AMPSSList *poAMPSSListPrev = NULL;  // pointer to previous node 

	curr = *list;
	while (curr)
	{
		poAMPSSListPrev = curr;
		curr = (t_AMPSSList*)curr->poAMPSSListNext;
		if (func_ptr)
		{
			func_ptr(poAMPSSListPrev->pvData, r_pvData);
		}
		AMPS_InternalFree(poAMPSSListPrev);
	}

	*list = NULL;

	return AMPS_SUCCESS;
}

/*****************************************************************
函数名称: SList_FreeEx
功能描述: 删除链表中指定的结点
入参::
      t_AMPSSList **list 原链表
      t_AMPSSList *node  待删除结点
      AMPS_LListFreeLinkDataCallback func_ptr 结点处理回调函数，如果结点
      的内存需要显式释放，使用此函数达到目的。

出参:
      t_AMPSSList *list
返回值:
      int

*****************************************************************/
int SList_Remove(t_AMPSSList **list, t_AMPSSList *node, AMPS_LListFreeLinkDataCallback func_ptr)
{
    if ((list == NULL) || (*list == NULL) || (node == NULL))
    {
        return AMPS_ERROR_FAILURE;
    }

    if (func_ptr)
    {
        /*处理待删除结点*/
        if (AMPS_ERROR_FAILURE == func_ptr(&(node->pvData)))
        {
            return AMPS_ERROR_FAILURE;
        }
    }

    /*待删除结点为头结点*/
    // If first element is found to be the element to be deleted
    if (NULL == node->poAMPSSListPrev)
    {
        /*待删除结点不是头结点，则返回失败*/
        if (*list != node)
        {
            printf("SList_Remove: list corrupted: poAMPSSListPrev pointer NULL but node is not the first element in list\n");
            return AMPS_ERROR_FAILURE;
        }
        *list = node->poAMPSSListNext;
        if (*list) // We have deleted the last element in the list
            (*list)->poAMPSSListPrev = NULL;
        AMPS_InternalFree(node);
        return AMPS_SUCCESS;      
    }

    /*待删除结点不是头结点*/
    node->poAMPSSListPrev->poAMPSSListNext = node->poAMPSSListNext;
    if (node->poAMPSSListNext)
    {
        node->poAMPSSListNext->poAMPSSListPrev = node->poAMPSSListPrev;
    }

    AMPS_InternalFree(node);
    return AMPS_SUCCESS;
}

/*****************************************************************
函数名称: SList_Count
功能描述: 计算链表中的结点个数
入参::
      const t_AMPSSList* list 原链表

出参:
      NA
返回值:
      int 结点数目

*****************************************************************/
unsigned int SList_Count(const t_AMPSSList* list)
{
    unsigned int uchCount = 0;
    t_AMPSSList* cur_ptr = (t_AMPSSList*)list;

    while (cur_ptr)
    {
        uchCount++;
        cur_ptr = cur_ptr->poAMPSSListNext;
    }

    return uchCount;
}

/*****************************************************************
函数名称: SList_Concat
功能描述: 连接两个链表
入参::
      t_AMPSSList** src 原链表
      t_AMPSSList* dst  待连接的链表

出参:
      NA
返回值:
      int 

*****************************************************************/
int SList_Concat(t_AMPSSList** src, t_AMPSSList* dst)
{
    t_AMPSSList *last = NULL;
    if (src == NULL || dst == NULL)
    {
        return AMPS_ERROR_FAILURE;
    }
    if (*src == NULL)
    {
        *src = dst;
    } else
    {
        last = SList_Last(*src);
        last->poAMPSSListNext = dst;
        dst->poAMPSSListPrev = last;
    }
    return AMPS_SUCCESS;
}

/*****************************************************************
函数名称: SList_AppendGivenNode
功能描述: 在链表头结点后插入指定结点
入参::
      void **list 原链表
      void* sListNode  待插入结点

出参:
      void **list
返回值:
      void 

*****************************************************************/
void SList_AppendGivenNode(void **list, void* sListNode)
{
	t_AMPSSList **slist = (t_AMPSSList**)list;
	t_AMPSSList* list_ptr = (t_AMPSSList*)*slist;
    t_AMPSSList* snode = (t_AMPSSList*)sListNode;
	
	if(!list_ptr)
	{
       *slist = snode;
	   return;
	}

	snode->poAMPSSListNext = list_ptr->poAMPSSListNext;
	snode->poAMPSSListPrev = list_ptr;
	list_ptr->poAMPSSListNext = snode;
}

/*****************************************************************
函数名称: SList_AppendGivenNode
功能描述: 在指定的结点后插入指定新结点
入参::
      void **list 原链表
      void* givenNode  指定的结点
      void* newNode 待插入结点

出参:
      void **list
返回值:
      void 

*****************************************************************/
void SList_PrependGivenNode(void **list, void* givenNode, void* newNode)
{
	t_AMPSSList **slist = (t_AMPSSList**)list;
	t_AMPSSList* node_ptr = (t_AMPSSList*)givenNode;
    t_AMPSSList* snode = (t_AMPSSList*)newNode;

	if(!node_ptr)
	{
       *slist = snode;
	   return;
	}

	snode->poAMPSSListNext = node_ptr;
	snode->poAMPSSListPrev = node_ptr->poAMPSSListPrev;
	if(NULL == node_ptr->poAMPSSListPrev)
	{
		*slist = snode;
	}
	else
	{
        node_ptr->poAMPSSListPrev->poAMPSSListNext = snode;
	}
	node_ptr->poAMPSSListPrev = snode;
	
}

/*****************************************************************
函数名称: SList_RemoveWithOutFree
功能描述: 删除链表中指定的结点，但不释放结点内容
入参::
      t_AMPSSList** r_ppoAMPSSListHead 原链表
      t_AMPSSList* r_poAMPSSListNode 待删除结点
      
出参:
      t_AMPSSList** r_ppoAMPSSListHead
返回值:
      int

*****************************************************************/

int SList_RemoveWithOutFree(t_AMPSSList** r_ppoAMPSSListHead, t_AMPSSList* r_poAMPSSListNode)
{
	if((NULL == r_ppoAMPSSListHead) || (NULL == *r_ppoAMPSSListHead) || (NULL == r_poAMPSSListNode))
    {
        return AMPS_ERROR_FAILURE;
    }

    /*待删除结点为头结点*/
    // If first element is found to be the element to be deleted
    if(NULL == r_poAMPSSListNode->poAMPSSListPrev)
    {
        if(*r_ppoAMPSSListHead != r_poAMPSSListNode)
        {
            printf("SList_RemoveWithOutFree: list corrupted: head's previous pointer is NULL but node is not the first element in the list\n");
            return AMPS_ERROR_FAILURE;
        }

        *r_ppoAMPSSListHead = r_poAMPSSListNode->poAMPSSListNext;
        if(NULL != *r_ppoAMPSSListHead) // Is the last element in the list deleted?
		{
            (*r_ppoAMPSSListHead)->poAMPSSListPrev = NULL;
		}
    }
	else
	{
		r_poAMPSSListNode->poAMPSSListPrev->poAMPSSListNext = r_poAMPSSListNode->poAMPSSListNext;
		if(NULL != r_poAMPSSListNode->poAMPSSListNext)
		{
			r_poAMPSSListNode->poAMPSSListNext->poAMPSSListPrev = r_poAMPSSListNode->poAMPSSListPrev;
		}
	}

	r_poAMPSSListNode->poAMPSSListNext = NULL;
	r_poAMPSSListNode->poAMPSSListPrev = NULL;

	return AMPS_SUCCESS;
}

/*****************************************************************
函数名称: SList_GetNextNode
功能描述: 取链表下一结点
入参::
      void* list 原链表
      
出参:
      t_AMPSSList** r_ppoAMPSSListHead
返回值:
      void* list

*****************************************************************/
void* SList_GetNextNode(void* list)
{
    t_AMPSSList *slist = (t_AMPSSList*)list;
	if(!slist)
	{
       return NULL;
	}
	return slist->poAMPSSListNext;
}

/*****************************************************************
函数名称: SList_GetNodeData
功能描述: 取指定结点内容
入参::
      void* node 原链表
      
出参:
      NA
返回值:
      void* 结点内容

*****************************************************************/
void* SList_GetNodeData(void* node)
{
    t_AMPSSList *slist = (t_AMPSSList*)node;
	if(!slist)
	{
       return NULL;
	}
	return slist->pvData;
}


socrates
关注
专栏目录
C:\Users\Administrator\Desktop\诺蒂菲尔设备资料AMPS-24.PDF
09-10
诺蒂菲尔设备资料AMPS-24、诺蒂菲尔设备资料AMPS-24、
【推荐】ON SEMI 运算放大器(Op Amps) 技术资料合集.zip
09-17
推荐，ON SEMI 运算放大器(Op Amps) 技术资料合集，共107份。 FAN3852-D 麦克风预放大器，带数字输出 FAN4174 运算放大器，轨对轨 IO，3.7Mhz，CMOS 运算放大器 FAN4274-D Single and Dual, Rail-to-Rail IO, CMOS ...
AMPS:MySQL数据库操作模块源码解读
Socrates的专栏
01-25 3354
本节看看在AMPS中对MySQL数据库的访问操作，它使用MySQL提供的C API接口进行访问，具体各API的使用可参考http://dev.mysql.com/doc/refman/5.6/en/c-api-function-overview.html。  下面看看AMPS中的实现：   AMPS_MySQL.h #ifndef __HEADER_AMPS_MYSQL_ENGINE_H #
AMPS:双向链表源码解读
Socrates的专栏
01-19 2889
本节在上节单向链表的基础上看看AMPS中对双向链表的实现，与单向链表相同，双向链表在软件中的使用也相对比较广泛，在后面要讲到的Hash表、定时器、内存管理等模块中都会见到以双向链表作为基本数据结构。其实，双向链表在实现上使用了很多单向链表的操作，仅在插入、删除结点时需要多操作几步，所以理解了单向链表，这块就比较好理解了。   同样，AMPS提供了以下API对双向链表进行操作：    AMPS
AMPS:定时器模块源码解读
Socrates的专栏
01-27 3142
Timer模块的实现比较复杂，需要结合前面的文章《AMPS:定时器管理》才能有所理解，下面看看AMPS中的定时器实现，有些细节方面我也没有想清楚。  AMPS_Timer.h #ifndef __HEADER_AMPS_TIMER_H__ #define __HEADER_AMPS_TIMER_H__ #ifdef __cplusplus extern "C" { #endif #
AMPS:哈希表源码解读
Socrates的专栏
01-21 3499
Hash表也是一种常用的数据结构，AMPS中的Hash表并不是给使用者提供一个散列函数，而是仅提供一个创建和维护Hash表这样一个结构的一组函数，针对不同的应用或者数据，由用户自己定义其要使用的散列函数，AMPS中，Hash表组成结构是如下的拉链式结构。 下面看看AMPS中对Hash操作的代码： AMPS_Hash.h #ifndef __HEADER_AMPS_HASH_H #
AMPS:日志模块源码解读
Socrates的专栏
01-24 2946
看看AMPS中的日志模块，有两种写日志的方法，一是直接使用封装好的API函数写，另一种是通过应用层注册的日志回调函数，利用事件管理机制来写。   AMPS_Log.h #ifndef __HEADER_AMPS_LOG_H__ #define __HEADER_AMPS_LOG_H__ #include #include "AMPS_SystemAPI.h" #include "AMP
AMPS:Cache模块源码解读
Socrates的专栏
01-27 2781
这里讲的Cache并不是通常说的计算机存储系统中的高速缓存，而是软件层面的缓存，它的做用主要是为了提高数据处理的效率。在AMPS中，Cache的结构如下： /*Cache结构*/ struct _AMPSCache { void* pvHASHTable; /*Hash表，用于查找*/ void* pvHeap; /*堆，用于增删改*/ int nCacheSize;
AMPS:Trace模块源码解读
Socrates的专栏
01-19 1673
从本节起，开始分析AMPS各模块的源码，其中主要地方均加了中文注释。   跟踪功能与通常软件使用的日志功能类似，但记录的信息比日志更详细，通过它可以看出整个代码的运行轨迹，AMPS支持多以下几种跟踪级别：  ERROR WARNING DEBUG DEBUG_2 INFO  并支持如下三种跟踪模式：   终端界面显示模式 文件记录模式   以上两种模式并存     下面是
AMPS:AES模块源码解读
Socrates的专栏
01-23 5710
AES(Advanced Encryption Standard，高级加密标准)是一个对称密钥加密算法，密钥长度则可以是128，192或256比特。  算法思路(详细信息请见维基百科)：   AES加密过程是在一个4×4的字节矩阵上运作，这个矩阵又称为“体（state）”，其初值就是一个明文区块（矩阵中一个元素大小就是明文区块中的一个Byte）。（Rijndael加密法因支持更大的区块
AMPS:队列源码解读
Socrates的专栏
01-19 2781
队列概念很简单，就是排队，先进先出，通常有链表形式和数组形式（即链接类型和顺序类型），它也是软件构建的一个基本数据结构，看看AMPS中的队列实现。  AMPS_Queue.h #ifndef __HEADER_AMPS_QUEUE_H #define __HEADER_AMPS_QUEUE_H #ifdef __cplusplus extern "C" { #endif #includ
解决AMPS悖论：小戏剧性与黑洞互补性
"这篇论文探讨了AMPS悖论与黑洞互补性的关系，提出了一种名为'小戏剧性'的新解决方案，以解决信息守恒问题。文章指出，即使没有明显的戏剧性事件，信息仍然可能看似违反一夫一妻制原则进入黑洞内部。然而，通过分析...
第三版Op Amps设计指南：实用设计工具和解决方案
Op Amps for Everyone (第三版) - Operational Amplifier 设计指南 Op Amps for Everyone (第三版) 是一本关于运算放大器（Operational Amplifier，简称 Op Amp）设计的指南，由 Ron Mancini 和 Bruce Carter 编辑...
运算放大器权威指南：OpAmps for Everyone 第三版
运算放大器（Op-Amps）是电子电路中的核心元件，广泛应用于信号处理、滤波、放大、比较、电源管理等各种场景。本书详细讲解了Op-Amp的基础概念，包括基本电路配置如非反相和反相放大器、电压跟随器、差分放大器等。...
AMPS:Oracle数据库操作模块源码解读
Socrates的专栏
01-25 3330
本节看看AMPS中对Oracle数据库进行操作的方法，使用的是Oracle的C访问接口OCI，关于OCI各函数的中文说明可参考这篇文章http://www.cnblogs.com/joeblackzqq/archive/2011/04/24/2026461.html  下面看看AMPS中Oracle操作各函数实现:  AMPS_Oracle.h #ifndef __HEADER_AMPS_D
AMPS:内存管理模块源码解读（一）
Socrates的专栏
01-27 3254
在AMPS中，使用内存池来管理内存，具体机制见之前的文章《AMPS:内存管理（二）》，在代码中，使用了两种实现方式，第一种是数组+单链表。今天先看看这个方式下的内存池实现。 AMPS_MemoryMgt.h #ifndef __HEADER_AMPS_MEMORY_MGMT_H__ #define __HEADER_AMPS_MEMORY_MGMT_H__ #include "AMPS_
AMPS:字符串操作源码解读
Socrates的专栏
01-21 3174
字符串处理在软件中非常普遍，AMPS使用C语言编写，所有没有像 标准C++提供的string一样的类型，所以对字符串的处理就是对char *这样的指针处理，为了处理方便，AMPS定义了自己的String类型，如下： typedef struct _AMPSString t_AMPSString; struct _AMPSString { unsigned char* puchData;
AMPS:数据库访问模块源码解读
Socrates的专栏
01-25 3128
AMPS做为一个中间件，也提供了访问数据库的接口，目前支持MySQL和Oracle（对我所喜爱PostgreSQL却默认不支持，看来我的爱好属于非主流哈~），下面要看的是DBEngine库，它只做一件事情，就是封装了不同数据库操作的差异，提供一个数据库统一访问接口。下节再看针对不同数据库的具体操作。 AMPS_DBEngine.h #ifndef __HEADER_AMPS_DB_ENGI
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值