/* 以下代码是测试动态库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__ */