C 封装一个通用链表 和 一个简单字符串开发库

#ifndef _H_LIST
#define _H_LIST

#include <schead.h>

/*
 *    这个万能单链表库 前提所有结点都是堆上分配的,设计的比较老了,能用
 *注意
 *    1.使用的时候,需要加上 _LIST_HEAD; 宏
 *    2.创建的第一句话就是 list head = NULL; 开始从空链表开始list的生涯
 */

struct __lnode {
    struct __lnode* next;
};

// 不多说了一定放在想使用链表结构的结构体头部
#define _LIST_HEAD     struct __lnode __ln;

// 简单链表结构, 当你使用这个链表的时候 需要 list_t head = NULL; 开始使用之旅
typedef void* list_t;

/*
 *  采用头查法插入结点, 第一使用需要 list_t head = NULL;
 *返回 _RT_OK 表示成功!
 * ph        : 指向头结点的指针
 * node        : 待插入的结点对象
 */
extern int list_add(list_t* ph, void* node);

/*
 * 链表中查找函数,查找失败返回NULL,查找成功直接返回那个结点,推荐不要乱改,否则就崩了.
 *如果需要改的话,推荐 用 list_findpop, 找到并弹出
 * h        : 链表头结点
 * cmp        : 查找的比较函数
 * left        : cmp(left, right) 用的左结点
 *            : 返回查找的结点对象
 */
extern void* list_find(list_t h, icmp_f cmp, const void* left);

/*
 * 查找到要的结点,并弹出,需要你自己回收
 * ph        : 指向头结点的指针
 * cmp        : 比较函数,将left同 *ph中对象按个比较
 * left        : cmp(left, x) 比较返回 0 >0 <0
 *            : 找到了退出/返回结点, 否则返回NULL
 */
extern void* list_findpop(list_t *ph, icmp_f cmp, const void* left);

/*
 * 这里获取当前链表长度, 推荐调用一次就记住len
 * h        : 当前链表的头结点
 *            : 返回 链表长度 >=0
 */
extern int list_len(list_t h);

/*
 * 查找索引位置为idx的结点,找不见返回NULL
 * h        : 当前结点
 * idx        : 查找的索引值[0,len)
 *            : 返回查到的结点,如果需要删除的推荐调用 list_pop(&h, idx);
 */
extern void* list_get(list_t h, int idx);

/*
 * 按照索引弹出并返回结点, 需要自己回收这个结点 推荐 free(list_pop...);
 * ph        : 指向链表结点的指针
 * idx        : 弹出的索引
 * return    : 无效的弹出,返回NULL
 */
void* list_pop(list_t* ph, int idx);

/*
 * 返回结点node 的上一个结点,如果node = NULL, 返回最后一个结点
 * h        : 当前链表结点
 * node        : 待查找的结点信息
 * return    : 返回查找到的结点,不存在返回NULL
 */
void* list_front(list_t h, void* node);

/*
 * 这个宏推荐不使用, 主要返回结点n的下一个结点
 * 第一种使用方法 node->next = (void*)list_node(n), 另一种是 list_node(n) = node;
 * n        : 当前结点
 */
#define list_next(n) \
    (((struct __lnode*)n)->next)

/*
 * 和 list_add 功能相似,但是插入位置在尾巴那
 * ph        : 待插入结点的指针
 * node        : 待插入的当前结点
 */ 
int list_addlast(list_t* ph, void* node);

/*
 * 在链表的第idx索引处插入结点,也必须需要 list_t head = NULL; 在idx过大的时候
 *插入尾巴处,如果<0直接返回 _RT_EP. 成功了返回 _RT_OK
 * ph        : 指向头结点的指针
 * idx        : 结点的索引处
 * node        : 待插入的结点
*/
int list_addidx(list_t* ph, int idx, void* node);

/*
 * 这里的销毁函数,只有这些数据都是栈上的才推荐这么做,会自动让其指向NULL
 * ph         : 指向当前链表结点的指针
 */
void list_destroy(list_t* ph);

#endif // !_H_LIST

#include <list.h>

struct lint {
    _LIST_HEAD;
    int node;
};

//简单创建函数
static struct lint* __lint_new(int node)
{
    struct lint* ln = malloc(sizeof(struct lint));
    if(ln){
        ln->node = node;
    }
    return ln;
} 

//简单打印函数
static void __lint_puts(list_t head)
{
    int len = list_len(head);
    int i;

    printf("当前链表中数据结果如下:");
    for(i=0; i<len; ++i){
        struct lint* tl = list_get(head, i);
        printf("%d ", tl->node);
    }
    putchar(‘\n‘);
}

/*
 * 这里简单测试一下 关于链表的常用接口
 */
int main(int argc, char* argv[])
{
    list_t head = NULL;    
    int arrs[] = { 1, 2, 3, 4, 5, 6, 7, 8};    
    int i;

    //这里添加结点
    for(i=0; i<sizeof(arrs)/sizeof(*arrs); ++i)
        list_add(&head, __lint_new(arrs[i]));
    
    __lint_puts(head);
    //这里删除一个结点
    free(list_pop(&head, 0));
    __lint_puts(head);

    //删除第二个结点
    free(list_pop(&head, 1));    
    __lint_puts(head);        

    list_destroy(&head);
    return 0;
}

/*
 * 这里获取当前链表长度, 推荐调用一次就记住len
 * h        : 当前链表的头结点
 *            : 返回 链表长度 >=0
 */
int list_len(list_t h)
{
    int len = 0;
    while(h){
        ++len;
        h = list_next(h);
    }
    return len;
}

#ifndef _H_TSTRING
#define _H_TSTRING

#include <schead.h>

//------------------------------------------------简单字符串辅助操作----------------------------------

/*
* 主要采用jshash 返回计算后的hash值
* 不冲突率在 80% 左右还可以, 不要传入NULL
*/
extern unsigned str_hash(const char* str);

//------------------------------------------------简单文本字符串辅助操作----------------------------------

#ifndef _STRUCT_TSTRING
#define _STRUCT_TSTRING
//简单字符串结构,并定义文本字符串类型tstring
struct tstring {
    char* str;        //字符串实际保存的内容
    int len;        //当前字符串大小
    int size;        //字符池大小
};
typedef struct  tstring* tstring;
#endif // !_STRUCT_TSTRING

//文本串栈上创建内容,不想用那些技巧了,就这样吧
#define TSTRING_CREATE(var)     struct tstring var = { NULL, 0, 0}
#define TSTRING_DESTROY(var)     free(var.str)

/*
 * tstring 的创建函数, 会根据str创建一个 tstring结构的字符串
 * 
 * str : 待创建的字符串
 * 
 * ret : 返回创建好的字符串,如果创建失败返回NULL
 */
extern tstring tstring_create(const char* str);

/*
 * tstring 完全销毁函数
 * tstr : 指向tsting字符串指针量的指针
 */
extern void tstring_destroy(tstring* tstr);

/*
 *  向简单文本字符串tstr中添加 一个字符c
 * tstr : 简单字符串对象
 * c : 待添加的字符
 * ret : 返回状态码 见 schead 中 _RT_EB 码等
 */
extern int tstring_append(tstring tstr, int c);

/*
 *  向简单文本串中添加只读字符串 
 * tstr : 文本串
 * str : 待添加的素材串
 * ret : 返回状态码主要是 _RT_EP _RT_EM
 */
extern int tstring_appends(tstring tstr, const char* str);

//------------------------------------------------简单文件辅助操作----------------------------------

/*
 * 简单的文件帮助类,会读取完毕这个文件内容返回,失败返回NULL.
 * 需要事后使用 tstring_destroy(&ret); 销毁这个字符串对象
 * path : 文件路径
 * ret : 返回创建好的字符串内容,返回NULL表示读取失败
 */
extern tstring file_malloc_readend(const char* path);

/*
 * 文件写入,没有好说的,会返回 _RT_EP _RT_EM _RT_OK
 * path : 文件路径
 * str : 待写入的字符串
 * ret : 返回写入的结果
 */
extern int file_writes(const char* path, const char* str);

/*
 * 文件追加内容, 添加str内同
 * path : 文件路径
 * str : 待追加的文件内同
 *     : 返回值,主要是 _RT_EP _RT_EM _RT_OK 这些状态
 */
extern int file_append(const char* path, const char* str);

#endif // !_H_TSTRING

#ifndef _STRUCT_TSTRING
#define _STRUCT_TSTRING
//简单字符串结构,并定义文本字符串类型tstring
struct tstring {
    char* str;        //字符串实际保存的内容
    int len;        //当前字符串大小
    int size;        //字符池大小
};
typedef struct  tstring* tstring;
#endif // !_STRUCT_TSTRING

//简单分配函数,智力一定会分配内存的, len > size的时候调用这个函数
static int __tstring_realloc(tstring tstr, int len)
{
    int size = tstr->size;
    for (size = size < _INT_TSTRING ? _INT_TSTRING : size; size < len; size <<= 1)
        ;
    //分配内存
    char *nstr = realloc(tstr->str, size);
    if (NULL == nstr) {
        SL_NOTICE("realloc(tstr->str:0x%p, size:%d) is error!", tstr->str, size);
        return _RT_EM;
    }
    tstr->str = nstr;
    tstr->size = size;
    return _RT_OK;
}

#include <tstring.h>
#include <sclog.h>

/*
* 主要采用jshash 返回计算后的hash值
* 不冲突率在 80% 左右还可以, 不要传入NULL
*/
unsigned 
str_hash(const char* str)
{
    size_t i, h = strlen(str), sp = (h >> 5) + 1;
    unsigned char* ptr = (unsigned char*)str;

    for (i = h; i >= sp; i -= sp)
        h ^= ((h<<5) + (h>>2) + ptr[i-1]);

    return h ? h : 1;
}

/*
* tstring 的创建函数, 会根据str创建一个 tstring结构的字符串
*
* str : 待创建的字符串
*
* ret : 返回创建好的字符串,如果创建失败返回NULL
*/
tstring 
tstring_create(const char* str)
{
    tstring tstr = calloc(1, sizeof(struct tstring));
    if (NULL == tstr) {
        SL_NOTICE("calloc is sizeof struct tstring error!");
        return NULL;
    }
    tstring_appends(tstr, str);

    return tstr;
}

/*
* tstring 完全销毁函数
* tstr : 指向tsting字符串指针量的指针
*/
void tstring_destroy(tstring* tstr)
{
    if (tstr && *tstr) { //展现内容
        free((*tstr)->str);
        free(*tstr);
        *tstr = NULL;
    }
}

//文本字符串创建的度量值
#define _INT_TSTRING (32)

//简单分配函数,智力一定会分配内存的, len > size的时候调用这个函数
static int __tstring_realloc(tstring tstr, int len)
{
    int size = tstr->size;
    for (size = size < _INT_TSTRING ? _INT_TSTRING : size; size < len; size <<= 1)
        ;
    //分配内存
    char *nstr = realloc(tstr->str, size);
    if (NULL == nstr) {
        SL_NOTICE("realloc(tstr->str:0x%p, size:%d) is error!", tstr->str, size);
        return _RT_EM;
    }
    tstr->str = nstr;
    tstr->size = size;
    return _RT_OK;
}

/*
*  向简单文本字符串tstr中添加 一个字符c
* tstr : 简单字符串对象
* c : 待添加的字符
* ret : 返回状态码 见 schead 中 _RT_EM 码等
*/
int tstring_append(tstring tstr, int c)
{
    //不做安全检查
    int len = tstr->len + 2; // c + ‘\0‘ 而len只指向 字符串strlen长度

    //需要进行内存分配,唯一损失
    if ((len > tstr->size) && (_RT_EM == __tstring_realloc(tstr, len)))
            return _RT_EM;

    tstr->len = --len;
    tstr->str[len - 1] = c;
    tstr->str[len] = ‘\0‘;

    return _RT_OK;
}

/*
*  向简单文本串中添加只读字符串
* tstr : 文本串
* str : 待添加的素材串
* ret : 返回状态码主要是 _RT_EP _RT_EM
*/
int tstring_appends(tstring tstr, const char* str)
{
    int len;
    if (!tstr || !str || !*str) {
        SL_NOTICE("check param ‘!tstr || !str || !*str‘");
        return _RT_EP;
    }

    len = tstr->len + strlen(str) + 1;
    if ((len > tstr->size) && (_RT_EM == __tstring_realloc(tstr, len)))
        return _RT_EM;

    //这里复制内容
    strcpy(tstr->str + tstr->len, str);
    tstr->len = len - 1;

    return _RT_OK;
}

//------------------------------------------------简单文件辅助操作----------------------------------

/*
* 简单的文件帮助类,会读取完毕这个文件内容返回,失败返回NULL.
* 需要事后使用 tstring_destroy(&ret); 销毁这个字符串对象
* path : 文件路径
* ret : 返回创建好的字符串内容,返回NULL表示读取失败
*/
tstring file_malloc_readend(const char* path)
{
    int c;
    tstring tstr;
    FILE* txt = fopen(path, "r");
    if (NULL == txt) {
        SL_NOTICE("fopen r path = ‘%s‘ error!", path);
        return NULL;
    }

    //这里创建文件对象,创建失败直接返回
    if ((tstr = tstring_create(NULL)) == NULL) {
        fclose(txt);
        return NULL;
    }

    //这里读取文本内容
    while ((c = fgetc(txt))!=EOF)
        if (_RT_OK != tstring_append(tstr, c))
            break;

    fclose(txt);//很重要创建了就要释放,否则会出现隐藏的句柄bug
    return tstr;
}

/*
* 文件写入,没有好说的,会返回 _RT_EP _RT_EM _RT_OK
* path : 文件路径
* str : 待写入的字符串
* ret : 返回写入的结果
*/
int file_writes(const char* path, const char* str)
{
    FILE* txt;
    //检查参数问题
    if (!path || !str) {
        SL_NOTICE("check is ‘!path || !str‘");
        return _RT_EP;
    }

    if ((txt = fopen(path, "w")) == NULL) {
        SL_NOTICE("fopen w path = ‘%s‘ error!", path);
        return _RT_EF;
    }

    //这里写入信息
    fputs(str, txt);

    fclose(txt);
    return _RT_OK;
}

/*
* 文件追加内容, 添加str内同
* path : 文件路径
* str : 待追加的文件内同
*     : 返回值,主要是 _RT_EP _RT_EM _RT_OK 这些状态
*/
int 
file_append(const char* path, const char* str)
{
    FILE* txt;
    //检查参数问题
    if (!path || !str) {
        SL_NOTICE("check is ‘!path || !str‘");
        return _RT_EP;
    }
    if ((txt = fopen(path, "a")) == NULL) {
        SL_NOTICE("fopen a path = ‘%s‘ error!", path);
        return _RT_EF;
    }
    //这里写入信息
    fputs(str, txt);

    fclose(txt);
    return _RT_OK;
}

main.out:main.c list.c schead.c
    gcc -g -Wall -o $@ $^ -I.

#ifndef _H_CHEAD
#define _H_CHEAD

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <errno.h>
#include <string.h>
#include <time.h>
#include <stdint.h>
#include <stddef.h>

/*
 * 1.0 错误定义宏 用于判断返回值状态的状态码 _RF表示返回标志
 *    使用举例 : 
         int flag = scconf_get("pursue");
         if(flag != _RT_OK){
            sclog_error("get config %s error! flag = %d.", "pursue", flag);
            exit(EXIT_FAILURE);
        }
 * 这里是内部 使用的通用返回值 标志
 */
#define _RT_OK        (0)                //结果正确的返回宏
#define _RT_EB        (-1)            //错误基类型,所有错误都可用它,在不清楚的情况下
#define _RT_EP        (-2)            //参数错误
#define _RT_EM        (-3)            //内存分配错误
#define _RT_EC        (-4)            //文件已经读取完毕或表示链接关闭
#define _RT_EF        (-5)            //文件打开失败

/*
 * 1.1 定义一些 通用的函数指针帮助,主要用于基库的封装中
 * 有构造函数, 释放函数, 比较函数等
 */
typedef void* (*pnew_f)();
typedef void(*vdel_f)(void* node);
// icmp_f 最好 是 int cmp(const void* ln,const void* rn); 标准结构
typedef int(*icmp_f)();

/*
 * 1.2 最简单的 判断字符串是否为空白字符代码, true为真
 */
#define sh_isspace(c) \
    (c==‘ ‘||c==‘\t‘||c==‘\n‘||c==‘\r‘||c==‘\v‘||c==‘\f‘)

/*
 *    2.0 如果定义了 __GNUC__ 就假定是 使用gcc 编译器,为Linux平台
 * 否则 认为是 Window 平台,不可否认宏是丑陋的
 */
#if defined(__GNUC__)
//下面是依赖 Linux 实现,等待毫秒数
#include <unistd.h>
#include <sys/time.h>
#define SLEEPMS(m) \
        usleep(m * 1000)
#else 
// 这里创建等待函数 以毫秒为单位 , 需要依赖操作系统实现
#include <Windows.h>
#include <direct.h> // 加载多余的头文件在 编译阶段会去掉
#define inline __inline    //附加一个内联函数宏
#define rmdir  _rmdir

/**
*    Linux sys/time.h 中获取时间函数在Windows上一种移植实现
**tv    :    返回结果包含秒数和微秒数
**tz    :    包含的时区,在window上这个变量没有用不返回
**        :   默认返回0
**/
extern int gettimeofday(struct timeval* tv, void* tz);

//为了解决 不通用功能
#define localtime_r(t, tm) localtime_s(tm, t)

#define SLEEPMS(m) \
        Sleep(m)
#endif /*__GNUC__ 跨平台的代码都很丑陋 */

//3.0 浮点数据判断宏帮助, __开头表示不希望你使用的宏
#define __DIFF(x, y)                ((x)-(y))                    //两个表达式做差宏
#define __IF_X(x, z)                ((x)<z&&(x)>-z)                //判断宏,z必须是宏常量
#define EQ(x, y, c)                    EQ_ZERO(__DIFF(x,y), c)        //判断x和y是否在误差范围内相等

//3.1 float判断定义的宏
#define _FLOAT_ZERO                (0.000001f)                        //float 0的误差判断值
#define EQ_FLOAT_ZERO(x)        __IF_X(x,_FLOAT_ZERO)            //float 判断x是否为零是返回true
#define EQ_FLOAT(x, y)            EQ(x, y, _FLOAT_ZERO)            //判断表达式x与y是否相等

//3.2 double判断定义的宏
#define _DOUBLE_ZERO            (0.000000000001)                //double 0误差判断值
#define EQ_DOUBLE_ZERO(x)        __IF_X(x,_DOUBLE_ZERO)            //double 判断x是否为零是返回true
#define EQ_DOUBLE(x,y)            EQ(x, y, _DOUBLE_ZERO)            //判断表达式x与y是否相等

//4.0 控制台打印错误信息, fmt必须是双引号括起来的宏
#ifndef CERR
#define CERR(fmt, ...) \
    fprintf(stderr,"[%s:%s:%d][error %d:%s]" fmt "\r\n",         __FILE__, __func__, __LINE__, errno, strerror(errno),##__VA_ARGS__)
#endif/* !CERR */

//4.1 控制台打印错误信息并退出, t同样fmt必须是 ""括起来的字符串常量
#ifndef CERR_EXIT
#define CERR_EXIT(fmt,...) \
    CERR(fmt,##__VA_ARGS__),exit(EXIT_FAILURE)
#endif/* !ERR */

#ifndef IF_CERR
/*
 *4.2 if 的 代码检测
 *
 * 举例:
 *        IF_CERR(fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP), "socket create error!");
 * 遇到问题打印日志直接退出,可以认为是一种简单模板
 *    code : 要检测的代码 
 *  fmt     : 必须是""括起来的字符串宏
 *    ...     : 后面的参数,参照printf
 */
#define IF_CERR(code, fmt, ...)        if((code) < 0)         CERR_EXIT(fmt, ##__VA_ARGS__)
#endif //!IF_CERR

//5.0 获取数组长度,只能是数组类型或""字符串常量,后者包含‘\0‘
#ifndef LEN
#define LEN(arr) \
    (sizeof(arr)/sizeof(*(arr)))
#endif/* !ARRLEN */

//6.0 程序清空屏幕函数
#ifndef CONSOLE_CLEAR
#ifndef _WIN32
#define CONSOLE_CLEAR() \
        system("printf ‘\ec‘")
#else
#define CONSOLE_CLEAR() \
        system("cls")
#endif/* _WIN32 */
#endif /*!CONSOLE_CLEAR*/

//7.0 置空操作
#ifndef BZERO
//v必须是个变量
#define BZERO(v) \
    memset(&v,0,sizeof(v))
#endif/* !BZERO */    

//9.0 scanf 健壮的
#ifndef SAFETY_SCANF
#define SAFETY_SCANF(scanf_code,...)     while(printf(__VA_ARGS__),scanf_code){        while(getchar()!=‘\n‘);        puts("输入出错,请按照提示重新操作!");    }    while(getchar()!=‘\n‘)
#endif /*!SAFETY_SCANF*/

//10.0 简单的time帮助宏
#ifndef TIME_PRINT
#define TIME_PRINT(code) {\
    clock_t __st,__et;    __st=clock();    code    __et=clock();    printf("当前代码块运行时间是:%lf秒\n",(0.0+__et-__st)/CLOCKS_PER_SEC);}
#endif /*!TIME_PRINT*/

//11.0 等待的宏 这里 已经处理好了
#define _STR_PAUSEMSG "请按任意键继续. . ."
extern void sh_pause(void);
#ifndef INIT_PAUSE

#    ifdef _DEBUG
#        define INIT_PAUSE() atexit(sh_pause)
#    else
#        define INIT_PAUSE()    (void)316 /* 别说了,都重新开始吧 */
#    endif

#endif/* !INIT_PAUSE */


//12.0 判断是大端序还是小端序,大端序返回true
extern bool sh_isbig(void);

/**
*    sh_free - 简单的释放内存函数,对free再封装了一下
**可以避免野指针
**pobj:指向待释放内存的指针(void*)
**/
extern void sh_free(void** pobj);

/**
*    获取 当前时间串,并塞入tstr中长度并返回
**    使用举例
    char tstr[64];
    puts(gettimes(tstr, LEN(tstr)));
**tstr    : 保存最后生成的最后串
**len    : tstr数组的长度
**        : 返回tstr首地址
**/
extern int sh_times(char tstr[], int len);

#endif/* ! _H_CHEAD */

#include <schead.h>

//简单通用的等待函数
void 
sh_pause(void)
{
    rewind(stdin);
    printf(_STR_PAUSEMSG);
    getchar();
}

//12.0 判断是大端序还是小端序,大端序返回true
bool 
sh_isbig(void)
{
    static union {
        unsigned short _s;
        unsigned char _cs[sizeof(unsigned short)];
    } __ut = { 1 };
    return __ut._cs[0] == 0;
}

/**
*    sh_free - 简单的释放内存函数,对free再封装了一下
**可以避免野指针
**@pobj:指向待释放内存的指针(void*)
**/
void 
sh_free(void** pobj)
{
    if (pobj == NULL || *pobj == NULL)
        return;
    free(*pobj);
    *pobj = NULL;
}

#if defined(_MSC_VER)
/**
*    Linux sys/time.h 中获取时间函数在Windows上一种移植实现
**tv    :    返回结果包含秒数和微秒数
**tz    :    包含的时区,在window上这个变量没有用不返回
**        :   默认返回0
**/
int 
gettimeofday(struct timeval* tv, void* tz)
{
    time_t clock;
    struct tm tm;
    SYSTEMTIME wtm;

    GetLocalTime(&wtm);
    tm.tm_year = wtm.wYear - 1900;
    tm.tm_mon = wtm.wMonth - 1; //window的计数更好写
    tm.tm_mday = wtm.wDay;
    tm.tm_hour = wtm.wHour;
    tm.tm_min = wtm.wMinute;
    tm.tm_sec = wtm.wSecond;
    tm.tm_isdst = -1; //不考虑夏令时
    clock = mktime(&tm);
    tv->tv_sec = (long)clock; //32位使用,接口已经老了
    tv->tv_usec = wtm.wMilliseconds * 1000;

    return _RT_OK;
}
#endif

/**
*    获取 当前时间串,并塞入tstr中C长度并返回
**    使用举例
char tstr[64];
puts(gettimes(tstr, LEN(tstr)));
**tstr    : 保存最后生成的最后串
**len    : tstr数组的长度
**        : 返回tstr首地址
**/
int 
sh_times(char tstr[], int len)
{
    struct tm st;
    time_t    t = time(NULL);
    localtime_r(&t, &st);
    return (int)strftime(tstr, len, "%F %X", &st);
}

#include <list.h>

/*
 *  采用头查法插入结点, 第一使用需要 list_t head = NULL;
 *返回 _RT_OK 表示成功!
 * ph        : 指向头结点的指针
 * node        : 待插入的结点对象
 */
int 
list_add(list_t* ph, void* node)
{
    if (ph == NULL || node == NULL){
        CERR("list_add 检查到(pal == NULL || node == NULL)!");
        return _RT_EP;
    }

    list_next(node) = *ph;
    *ph = node;

    return _RT_OK;
}

/*
 * 链表中查找函数,查找失败返回NULL,查找成功直接返回那个结点,推荐不要乱改,否则就崩了.
 *如果需要改的话,推荐 用 list_findpop, 找到并弹出
 * h        : 链表头结点
 * cmp        : 查找的比较函数
 * left        : cmp(left, right) 用的左结点
 *            : 返回查找的结点对象
 */
void* 
list_find(list_t h, icmp_f cmp, const void* left)
{
    struct __lnode* head;
    if(cmp == NULL || left == NULL){
        CERR("list_find 检查到(cmp == NULL || left == NULL)!");
        return NULL;
    }
    //找到结果直接结束
    for(head = h; head; head = head->next)
        if(cmp(left, head) == 0)
            break;
    return head;
}

/*
 * 查找到要的结点,并弹出,需要你自己回收
 * ph        : 指向头结点的指针
 * cmp        : 比较函数,将left同 *ph中对象按个比较
 * left        : cmp(left, x) 比较返回 0 >0 <0
 *            : 找到了退出/返回结点, 否则返回NULL
 */
void* 
list_findpop(list_t *ph, icmp_f cmp, const void* left)
{
    struct __lnode *head, *tmp;
    if((!ph) || (!cmp) || (!left) || !(head = *ph)){
        CERR("check find {(!ph) || (!cmp) || (!left) || !(head = *ph)}!");
        return NULL;
    }
    //头部检测
    if(cmp(left, head) == 0){
        *ph = head->next;
        return head;
    }
    //后面就是普通的
    while((tmp = head->next)){
        if(cmp(left, tmp) == 0){
            head->next = tmp->next;
            break;
        }
        head = tmp;
    }
    
    return tmp; //仍然没有找见
}

/*
 * 这里获取当前链表长度, 推荐调用一次就记住len
 * h        : 当前链表的头结点
 *            : 返回 链表长度 >=0
 */
int list_len(list_t h)
{
    int len = 0;
    while(h){
        ++len;
        h = list_next(h);
    }
    return len;
}

/*
 * 查找索引位置为idx的结点,找不见返回NULL
 * h        : 当前结点
 * idx        : 查找的索引值[0,len)
 *            : 返回查到的结点,如果需要删除的推荐调用 list_pop(&h, idx);
 */
void* 
list_get(list_t h, int idx)
{
    if(h==NULL || idx < 0){
        CERR("check is {h==NULL || idx < 0}");
        return NULL;
    }
    //主要查找函数,代码还是比较精简的还是值得学习的
    while(h){
        if(idx-- == 0)
            return h;
        h = list_next(h);
    }
    
    if(idx > 0)
        CERR("check is idx >= length!, idx-length=%d.", idx);
    return NULL;
}

/*
 * 按照索引弹出并返回结点, 需要自己回收这个结点 推荐 free(list_pop...);
 * ph        : 指向链表结点的指针
 * idx        : 弹出的索引
 * return    : 无效的弹出,返回NULL
 */
void* 
list_pop(list_t* ph, int idx)
{
    struct __lnode *head, *front;//第一个是要找的结点,后面是它的前驱结点
    if((!ph) || (idx<0) || !(head=*ph)){
        CERR("check is {(!ph) || (idx<0) || !(head=*ph)}");
        return NULL;
    }
    
    for(front = NULL; head && idx>0; --idx){
        front = head;
        head = head->next;
        --idx;
    }
    
    if(idx>0){
        CERR("check is idx>length, idx-length = %d.", idx);
        return NULL;
    }
    //下面就是找到的请况,返回结果
    if(front == NULL)
        *ph = head->next;
    else
        front->next = head->next;
    return head;
}

/*
 * 返回结点node 的上一个结点,如果node = NULL, 返回最后一个结点
 * h        : 当前链表结点
 * node        : 待查找的结点信息
 * return    : 返回查找到的结点,不存在返回NULL
 */
void* 
list_front(list_t h, void* node)
{
    struct __lnode* head = h; //直接跑到崩溃同strcpy
    while(head->next && head->next != node)
        head = head->next;
    return head->next == node ? head : NULL;
}

/*
 * 和 list_add 功能相似,但是插入位置在尾巴那
 * ph        : 待插入结点的指针
 * node        : 待插入的当前结点
 */ 
int 
list_addlast(list_t* ph, void* node)
{
    struct __lnode* head;
    if(!ph || !node){
        CERR("check is {!ph || !node}! not nothing in it!");
        return _RT_EP;
    }
    
    list_next(node) = NULL;//将这个结点的置空
    if(!(head=*ph)){ //插入的是头结点直接返回
        *ph = node;
        return _RT_OK;
    }
    
    while(head->next)
        head = head->next;
    head->next = node;
    return _RT_OK;
}

/*
 * 在链表的第idx索引处插入结点,也必须需要 list_t head = NULL; 在idx过大的时候
 *插入尾巴处,如果<0直接返回 _RT_EP. 成功了返回 _RT_OK
 * ph        : 指向头结点的指针
 * idx        : 结点的索引处
 * node        : 待插入的结点
*/
int 
list_addidx(list_t* ph, int idx, void* node)
{
    struct __lnode* head;
    if(!ph || idx<0 || !node){ //以后可能加入 idx < 0的尾巴插入细则
        CERR("check is {!ph || idx<0 || !node}! Don‘t naughty again!");
        return _RT_EP;
    }
    //插入做为头结点
    if(!(head=*ph) || idx == 0){
        list_next(node) = *ph;
        *ph = node;
        return _RT_OK;
    }
    
    while(head->next && idx>1){
        --idx;
        head = head->next;
    }
    list_next(node) = head->next;
    head->next = node;
    return _RT_OK;
}

/*
 * 这里的销毁函数,只有这些数据都是栈上的才推荐这么做,会自动让其指向NULL
 * ph         : 指向当前链表结点的指针
 */
void 
list_destroy(list_t* ph)
{
    struct __lnode *head, *next;
    if((!ph) || !(head=*ph))
        return;
    do{ //do 循环可以省略一次判断,但是有点丑陋
        next = head->next;
        free(head);
    }while((head=next));
    
    *ph = NULL;
}