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

引言

　　这里需要分享的是一个 简单字符串库和 链表的基库,代码也许用到特定技巧.有时候回想一下,

如果我读书的时候有人告诉我这些关于C开发的积淀, 那么会走的多直啊.刚参加工作的时候做桌面开发,

服务是C++写,界面是C#写.那时候刚进去评级我是中级,因为他问我关于系统锁和信号量都答出来.开发一段

时间,写C#也写的很溜.后面招我那个人让我转行就写C++和php,那时候就开始学习C++有关知识.

后面去四川工作了,开发安卓,用eclipse + java语法 + android jdk,开发前端,用起来,我的感受,都相似,就是api名字

有点长. 都是那老套路,后来四川公司黄了. 辗转又来了北京做C系列还有php开发. 说了这么多, 我想说下面几个问题.

　　1. 你写的是 C# 和 java吗,还只是.net/jdk的积木 , 写了那么多这样的代码,你感到疑惑吗?

　　2.假如你也感到过疑惑, 推荐去看看 Linux程序开发 或 unix环境编程, 网络编程

//2.1 不推荐认真学C++, 学了好多,看了好多书,还是不明觉历,觉得是在杂耍! 如果喜欢C,把市面上好的C书都看一遍,敲一遍!

3. 因为随着年纪增长,效率太重要了, 需要去找到学到那些一招鲜吃遍天的东西, 其它的让年起人去拼搏吧.

有时候想想,做软件开发,初中就够了,高中绰绰有余,大学研究生都暴遣天物. 大家觉得呢.

又扯了一会儿蛋, 今天分享的还是很有用的,但是感觉没接触这样黑科技的还是有点难. 或者说封装一个框架还是有难度的,

或者,哪怕再小的一个库封装完毕都是不容易的.而我们分享的是封装库的库. 个人比较水,打脸要轻打.

用到的资源

　　list 测试demo http://download.csdn.net/detail/wangzhione/9428243

入行第一篇博文 C的回归(国内超一线)   http://blog.codingnow.com/2007/09/c_vs_cplusplus.html

再扯一点, 2015 北京平均工资最高的三个职业 IT 特殊服务业 电子设备. 如果你穷你真的需要 认真学习编程,不要太沉迷于框架的学习中.

真的 人穷就应该多编程, 别人抢红包,你 需要写代码, , ,

前言

　　终于到这里了,扯的有点多. 首先来看一下今天主要写的通用链表的接口,看设计

#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

这里接口使用的 extern声明的希望外部直接使用, 没有extern的外部可以使用,属于扩展功能.
对于上面接口 简单的测试 代码如下

#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;
}

测试了几个简答接口. 注释比较详细, 写的也比较简单相对于Linux内核的数据结构而言. 这里是个开门红.
临摹几遍都能理解C接口的简单设计.

正文

　　其实呀上面代码主要突出一个设计, 实现而言还是比较容易,因为结构有了,算法就能够写好了. 例如 获取某个结点的源码

/*
 * 这里获取当前链表长度, 推荐调用一次就记住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

这个串可以用在读取一个大串,主要解决的问题是内存空间分配问题,还可以用.最大浪费就50%.

现在我们简单说一下具体实现,其实一看

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

全部明白了. 就是 len表现当前str中保存的长度, size表现当前str的容量.分配代码如下

//简单分配函数,智力一定会分配内存的, 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;
}

len是新的str大小.后面展现 全部的演示代码.

#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;
}

相比云风的那个玩具要简单的多,而且针对性很强,就为了大字符串. 转存用.还可以一试.

到这里就到了今天一个主题. 主要测试list demo. 首先看运行的结果图

首先看Makefile 文件

main.out:main.c list.c schead.c
    gcc -g -Wall -o [email protected] $^ -I.

再看schead.h 文件

#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 */

主要是跨平台的一些帮助宏,开发中用到的通用宏.具体schead.c实现如下

#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);
}

后面是list.c的具体实现了

#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;
}

关于list写的比较多,也有一点简单理解,上面虽然简陋,但是很精简,很指导不知道朋友学习使用,很通用的实在库. 到这里我们的一些都

这么随意的介绍完了.

　　再次分享个人学习习惯,别人说的太多,还是不懂,直接让我看代码就可以了,每次都是对着代码敲明白了.当然老外的书说的很明白,不得不服.

一下就懂了. 每一个大功能都是一个个小模块组成了, 没经过坑坑洼洼, 自己都不相信自己可以. 不管怎么选择都很公平,需要是 用 高付出, 在第8号当铺典当

你想要的东西.

　　共勉.希望的我的家人常快乐, 儿子在外对不住您们了, 目送飞云,一切安好!

后记

　　错误是难免的,欢迎交流技术. 其实这个框架整体代码去年早就写好了, 后面有了点项目感悟,重新构建一下,提升性能,

就简单分享在这,值得和我一样菜的人学习交流. 设计很重要,但绝壁不是设计模式. 拜~,有机会 下次再分享感悟.