C的常用模板函数接口2 --字符串操作、排序等

/* 以下代码是测试动态库libxiyuan.so或静态库xiyuanlib.a的容器
   操作的testVessel.c源代码。
其中：(该版本加入容器属性)
    1.加入容器属性，VAssemble_t类型的容器，可以接收任何类型的
      数据，内核使用的是线性循环双向链表。
    2.该容器可以对数据根据比较函数的不同，进行不同的排序；
    3.该容器可以根据key值的和key对应的依据函数，进行不同的元素
      的删除；
    4.该容器具体多种方法，判断容器长度，是否为空等；
    该容器后续还有继续更新；
对应的库文件和头文件下载地址：
    https://pan.baidu.com/s/100Xb5cd-KM4QSsy-2hbatA */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "xy_vessel_code.h"

typedef struct sTestData
{
	int key;
	char *name;
	float value;
} TestData_t;

int comple2(const TestData_t *value1, const TestData_t *value2)
{
	if (0 == strcmp(value1->name, value2->name))
		return 0;
	else if (strcmp(value1->name, value2->name) > 0)
		return 1;
	else
		return -1;
}

int comple3(const TestData_t *value1, const TestData_t *value2)
{
	if (value1->key == value2->key)
		return 0;
	else if (value1->key > value2->key)
		return 1;
	else
		return -1;
}

void printfElem1(TestData_t *pNode)
{
	printf("key: %d, %s, %f\n",pNode->key,pNode->name,pNode->value);	
}

int ExistAccording(const void *key, const void *value)
{
	if (*(int *)key == ((TestData_t *)value)->key)
		return 0;
	else
		return -1;	
}

int ExistAccording2(const void *key, const void *value)
{
	if (0 == strcmp(key, ((TestData_t *)value)->name))
		return 0;
	else
		return -1;	
}


int main(int argc, const char *argv[])
{
	int i = 0, key = 0; 
	VAssemble_t vassem2;
	
	// 初始化 vassem1 vassem2
	InitVessel(&vassem2, (int (*)(const void *, const void *))comple2);			
	TestData_t testdata[8] = {{5, "ssss", 25.6}, 
			{8, "dddd", 66.66}, 
			{1, "ddee", 77.56},
			{6, "wedfd", 88.92},
			{5, "dsgvsd", 56.2123},
			{3, "541sdsd", 87.2},
			{18, "sdfsdv", 98.6},
			{0, "cxvxcv", 65.23},};
	
	printf("init vassem2---length:%d\n", GetLengthOfVessel(&vassem2));
	for (i = 0; i < 8; i++)
	{
		AddToVessel(&vassem2, &testdata[i], sizeof(TestData_t));	
	}
	
	printf("vassem2 TestData_t-----------------\n");
	ShowOfVessel(&vassem2, (void (*)(void *))printfElem1);
	
	printf("default sort:\n");
	SortFromVessel(&vassem2, NULL);
	ShowOfVessel(&vassem2, (void (*)(void *))printfElem1);
	
	printf("key sort:\n");
	SortFromVessel(&vassem2, (int (*)(const void *, const void *))comple3);
	ShowOfVessel(&vassem2, (void (*)(void *))printfElem1);
	
	printf("vassem2---length:%d\n", GetLengthOfVessel(&vassem2));
	
	void *pkey = NULL;
	printf("get index 5:\n");
	if (NULL != (pkey=GetIndexOfVessel(&vassem2, 5)))
	{
		printfElem1(pkey);	
	}
	
	char *pKeydata1 = "cxvxcv";
	printf("find cxvxcv\n");
	pkey = GetKeyOfVessel(&vassem2, pKeydata1, ExistAccording2);
	printfElem1((TestData_t *)pkey);
	
	printf("delete cxvxcv\n");
	if (NULL != pkey)
	{
  	DeleteFromVessel(&vassem2, pkey);
	}
	ShowOfVessel(&vassem2, (void (*)(void *))printfElem1);
	
	int Keydata2 = 18;
	printf("delete sdfsdv\n");
	if (NULL != (pkey = GetKeyOfVessel(&vassem2, &Keydata2, ExistAccording)))
	{
  	DeleteFromVessel(&vassem2, pkey);
	}
	ShowOfVessel(&vassem2, (void (*)(void *))printfElem1);
	
	TestData_t Keydata3 = {6, "wedfd", 88.92};
	printf("delete wedfd\n");
	DeleteFromVessel(&vassem2, &Keydata3);
	ShowOfVessel(&vassem2, (void (*)(void *))printfElem1);
	
	printf("vassem2--ss-length:%d\n", GetLengthOfVessel(&vassem2));
	
	printf("FreeFromVessel\n");
	FreeFromVessel(&vassem2);
	ShowOfVessel(&vassem2, (void (*)(void *))printfElem1);
	
	return 0;	
}

/* xy_vessel_code.h */
#ifndef __XY_VESSEL_CODE_H__
#define __XY_VESSEL_CODE_H__

/*
** Make sure we can call this stuff from C++.
*/
#ifdef __cplusplus
extern "C" {
#endif

#ifndef XIYUAN_API  
#define XIYUAN_API
#endif

typedef int (*fcompleFunc_t)(const void *, const void *);


//***  XIYUAN_API 接口函数说明  ***//

XIYUAN_API typedef struct sVAssemble
{
	void *pBase;               // 数据存储的基指针
	const void *pBaseMethod;   // 数据操作方法的指针
	fcompleFunc_t compleFunc;  // 数据比较的默认操作的函数指针
} VAssemble_t, *PVAssemble_t;

/** 
 * \fn XIYUAN_API int InitVessel(VAssemble_t *pAssemble,
    int (*compleFunc)(const void *, const void *))
 * \brief 初始化集合pAssemble对象
 * \param pAssemble   [in] 参数名称，集合对象的指针
 * \param compleFunc  [in] 参数名称，集合对象的比较函数
 * \return
 *			  0		: 成功			\n
 *		   -1		: 初始化失败	\n
 */
XIYUAN_API int InitVessel(VAssemble_t *pAssemble, 
int (*compleFunc)(const void *, const void *));

/** 
 * \fn XIYUAN_API int AddToVessel(VAssemble_t *pAssemble, 
const void *pElement, size_t elemLen)
 * \brief 向集合pAssemble中添加一个元素
 * \param pAssemble   [in] 参数名称，集合对象的指针
 * \param pElement    [in] 参数名称，添加元素数据的指针
 * \param elemLen     [in] 参数名称，添加元素的数据长度
 * \return
 *			  0		: 成功			\n
 *		   -1		: 添加失败	\n
 */
XIYUAN_API int AddToVessel(VAssemble_t *pAssemble, 
const void *pElement, size_t elemLen);

/** 
 * \fn XIYUAN_API int SortFromVessel(VAssemble_t *pAssemble)
 * \brief 对集合pAssemble进行排序
 * \param pAssemble   [in] 参数名称，集合对象的指针
 * \param compleFunc  [in] 参数名称，集合对象的比较函数
 * \return
 *			  0		: 成功			\n
 *		   -1		: 集合排序操作失败	\n
 */
XIYUAN_API int SortFromVessel(VAssemble_t *pAssemble, 
int (*compleFunc)(const void *, const void *));

/** 
 * \fn XIYUAN_API int DeleteFromVessel(VAssemble_t *pAssemble, void *pElement)
 * \brief 删除集合pAssemble中的pElement元素
 * \param pAssemble   [in] 参数名称，集合对象的指针
 * \param pElement    [in] 参数名称，要删除的集合元素的指针
 * \return
 *			  0		: 成功			\n
 *		   -1		: 删除元素失败	\n
 */
XIYUAN_API int DeleteFromVessel(VAssemble_t *pAssemble, void *pElement);

/** 
 * \fn XIYUAN_API void *GetKeyOfVessel(VAssemble_t *pAssemble, void *key, 
    int (*ExistAccording)(const void *, const void *))
 * \brief 寻找集合中是否存在key对应的元素
 * \param pAssemble       [in] 参数名称，集合对象的指针
 * \param key             [in] 参数名称，元素对应的key值
 * \param ExistAccording  [in] 参数名称，key对应的元素的判断依据函数
 * \return
 *			  !NULL		: 成功			\n
 *		    NULL		: 不存在与key值相等的元素	\n
 */
XIYUAN_API void *GetKeyOfVessel(VAssemble_t *pAssemble, 
void *key, int (*ExistAccording)(const void *, const void *));

/** 
 * \fn XIYUAN_API void *GetIndexOfVessel(VAssemble_t *pAssemble, int Index)
 * \brief 寻找集合中Index位置所对应的元素
 * \param pAssemble     [in] 参数名称，集合对象的指针
 * \param Index         [in] 参数名称，元素在集合中的位置
 * \return
 *			  !NULL		: 成功			\n
 *		    NULL		: 不存在与Index位置对应的元素	\n
 */
XIYUAN_API void *GetIndexOfVessel(VAssemble_t *pAssemble, int Index);

/** 
 * \fn XIYUAN_API int GetLengthOfVessel(VAssemble_t *pAssemble)
 * \brief 计算集合中元素的个数
 * \param pAssemble     [in] 参数名称，集合对象的指针
 * \return
 *			  !0		: 集合中元素的个数	\n
 *		     0		: 集合中元素为0	    \n
 */
XIYUAN_API int GetLengthOfVessel(VAssemble_t *pAssemble);

/** 
 * \fn XIYUAN_API void FreeFromVessel(VAssemble_t *pAssemble)
 * \brief 释放集合pAssemble中元素的动态内存
 * \param pAssemble   [in] 参数名称，集合对象的指针
 * \return
 */
XIYUAN_API void FreeFromVessel(VAssemble_t *pAssemble);

/** 
 * \fn XIYUAN_API void ShowOfVessel(VAssemble_t *pAssemble, 
void (*printElem)(void *pNode))
 * \brief 显示集合pAssemble中元素的数据
 * \param pAssemble   [in] 参数名称，集合对象的指针
 * \param printElem   [in] 参数名称，打印集合元素的函数
 * \return
 */
XIYUAN_API void ShowOfVessel(VAssemble_t *pAssemble, 
void (*printElem)(void *pNode));


#ifdef __cplusplus
}
#endif

#endif /* __XY_VESSEL_CODE_H__ */

/* xy_list_code.h */
#ifndef __XY_LIST_CODE_H__
#define __XY_LIST_CODE_H__

/*
** Make sure we can call this stuff from C++.
*/
#ifdef __cplusplus
extern "C" {
#endif

#ifndef XIYUAN_API  
#define XIYUAN_API
#endif

//***  XIYUAN_API 接口函数说明  ***//

// 双向循环链表所支持的函数接口集合
XIYUAN_API typedef struct sLinkListMethod
{
	/** 
	 * \fn int InitLinkList(void **pHead)
	 * \brief 初始化双向循环链表
	 * \param pHead    [in] 参数名称，双向链表指针头节点的指针
	 * \return
	 *			  0		: 成功			\n
	 *		   -1		: 初始化失败\n
	 */
	int ( *InitLinkList )( void **pHead );
	
	/** 
	 * \fn int InsertLinkList(void **pHead, void *pNode)
	 * \brief 向双向循环链表pHead中插入节点pNode
	 * \param pHead    [in] 参数名称，双向链表指针头节点的指针
	 * \param pNode    [in] 参数名称，插入的节点指针
	 * \return
	 *			  0		: 成功			\n
	 *		   -1		: 头指针节点的地址为NULL	\n
	 *		   -2		: 插入失败  \n
	 */
	int ( *InsertLinkList )( void **pHead, void *pNode );
	
	/** 
	 * \fn int DeleteLinkList(void **pHead, void *key, 
	 		int (*ExistAccording)(const void *, const void *))
	 * \brief 删除双向循环链表pHead中值为key的节点
	 * \param pHead       [in] 参数名称，双向链表指针头节点的指针
	 * \param key         [in] 参数名称，删除节点的key值
	 * \param compleFunc  [in] 参数名称，比较函数
	 * \return
	 *			  0		: 成功			\n
	 *		   -1		: 头指针节点的地址为NULL	\n
	 *		   -2		: key指针为NULL  \n
	 *		   -3		: 删除失败  \n
	 */
	int ( *DeleteLinkList )( void **pHead, void *key, 
int (*ExistAccording)(const void *, const void *) );
	
	/** 
	 * \fn void *FindLinkList(void *pHead, void *key, 
	    int (*ExistAccording)(const void *, const void *))
	 * \brief 寻找双向循环链表pHead中是否存在key的节点 返回节点指针
	 * \param pHead          [in] 参数名称，双向链表指针头节点
	 * \param key            [in] 参数名称，节点的key值
	 * \param ExistAccording [in] 参数名称，key值在节点中是否存在的判断函数
	 * \return
	 *			  !NULL		: 成功			\n
	 *		    NULL		: 不存在与key值相等的节点	\n
	 */
	void *( *FindLinkList )( void *pHead, void *key, 
int (*ExistAccording)(const void *, const void *) );
	
	/** 
	 * \fn int GetLinkListLength(void *pHead)
	 * \brief 寻找双向循环链表pHead中是否存在key的节点 返回节点指针
	 * \param pHead   [in] 参数名称，双向链表指针头节点
	 * \return
	 *			  !0  	: 链表的长度	\n
	 *		     0   	: 链表长度为0	\n
	 */
	int ( *GetLinkListLength )( void *pHead );
	
	/** 
	 * \fn int IsLinkListEmpty(void *pHead)
	 * \brief 判断双向循环链表是否为空
	 * \param pHead  [in] 参数名称，双向链表指针头节点
	 * \return
	 *			  0		: 链表为空		\n
	 *		    1		: 链表不为空	\n
	 */
	int ( *IsLinkListEmpty )( void *pHead );
	
	/** 
	 * \fn void *FindLinkListIndex(void *pHead, int index)
	 * \brief 根据index的指示返回双向循环链表pHead中的节点 返回节点指针
	 * \param pHead   [in] 参数名称，双向链表指针头节点
	 * \param index   [in] 参数名称，节点在链表中的位置
	 * \return
	 *			  !NULL		: 成功			\n
	 *		    NULL		: 不存在与key值相等的节点	\n
	 */
   void *( *FindLinkListIndex )( void *pHead, int index );
	
	/** 
	 * \fn void *GetLinkListData(void *pHead, void *pList)
	 * \brief 获取双向循环链表pHead的节点pList中的数据指针
	 * \param pHead      [in] 参数名称，双向链表指针头节点
	 * \param pList      [in] 参数名称，当前节点成员pList
	 * \return
	 *			  !NULL		: 成功			\n
	 *		    NULL		: pList=NULL	\n
	 */
	void *( *GetLinkListData )( void *pHead, void *pList );
	/** 
	 * \fn void *GetLinkListPrev(void *pHead, void *pList)
	 * \brief 获取双向循环链表pHead的节点pList中的前节点指针
	 * \param pHead      [in] 参数名称，双向链表指针头节点
	 * \param pList      [in] 参数名称，当前节点成员pList
	 * \return
	 *			  !NULL		: 成功			\n
	 *		    NULL		: pList=NULL	\n
	 */
	void *( *GetLinkListPrev )( void *pHead, void *pList );
	/** 
	 * \fn void *GetLinkListNext(void *pHead, void *pList)
	 * \brief 获取双向循环链表pHead的节点pList中的后节点指针
	 * \param pHead      [in] 参数名称，双向链表指针头节点
	 * \param pList      [in] 参数名称，当前节点成员pList
	 * \return
	 *			  !NULL		: 成功			\n
	 *		    NULL		: pList=NULL	\n
	 */
	void *( *GetLinkListNext )( void *pHead, void *pList );
	
	/** 
	 * \fn void FreeLinkList(void **pHead)
	 * \brief 释放双向循环链表pHead中所有节点的内存
	 * \param pHead  [in] 参数名称，双向链表指针头节点
	 * \return
	 */
	void ( *FreeLinkList )( void *pHead );
	
	/** 
	 * \fn void SortLinkList(void *pHead, int (*compleFunc)(const void *, const void *))
	 * \brief 对链表pHead中的节点按比较函数进行排序， 使用冒泡排序法
	 * \param pHead   	  [in] 参数名称，双向链表指针头节点
	 * \param compleFunc  [in] 参数名称，比较函数
	 * \return
	 */
	void ( *SortLinkList )( void *pHead, int (*compleFunc)(const void *, const void *) );
	
	/** 
	 * \fn void TraverseList(void *pHead, void (*printElem)(void *pNode))
	 * \brief 遍历双向循环链表pHead中所有节点的内存
	 * \param pHead       [in] 参数名称，双向链表指针头节点
	 * \param printElem   [in] 参数名称，打印节点内容函数
	 * \return
	 */
	void ( *TraverseList )( void *pHead, void (*printElem)(void *pNode) );
	
} LinkListMethod_t;

/** 
 * \fn XIYUAN_API LinkListFrame_t *GetListMethod(void)
 * \brief 获取双向循环链表的函数接口对象
 * \return
 *   非NULL   : 成功			\n
 *	 NULL  	  : 获取失败	\n
 */
XIYUAN_API const LinkListMethod_t *GetListMethod(void);


#ifdef __cplusplus
}
#endif

#endif /* __XY_LIST_CODE_H__ */