记得之前写了个常用函数头文件~不过现在学多一点内容重新写感觉会好看一点,这个是初测版还有很多没有完善~

P_________S:最新代码15楼更!
Common.h

#include"Common.h"

#define _NDEBUG false

#if _NDEBUG==true
    #define NDEBUG
#endif

#include<assert.h>

#define NODE_ISNULL true
#define MEMSET_SET  true
#define DEL_SET_NULL true

bool Node_Creat(void**Node,const size_t Size)
{
    
    #if NODE_ISNULL==true
        if (*Node!=NULL)
            return false;
    #else
        free(*Node);
    #endif
        
    *Node=malloc(Size);
    
    #ifndef NDEBUG
        assert(*Node);
    #else
            if (*Node==NULL)
                return false;
    #endif
    
    
    #if MEMSET_SET==true
        memset(*Node,0,Size);
    #endif
    
    return true;
    
}

bool Node_Realloc(void**Node,const size_t Size)
{
    #ifdef NDEBUG
         void* np=*Node;   
     #endif
     
    *Node=realloc(*Node,Size);
    
    #ifndef NDEBUG
        assert(*Node);
    #else
         if (*Node==NULL)       
         {       
               *Node=np;
                return false;
         }
    #endif
    
    return true;
    
}

bool Node_Free(void** Node)
{
    if (*Node==NULL)
        return false;
        
    free(*Node);
    
    #if DEL_SET_NULL==true
        *Node=NULL;
    #endif
    
    return true;
}

int String_Get(FILE* fp,char** p,int end_signe)
{
    int c=0;
    unsigned len=0;
    char* pt=NULL;
    ptrdiff_t capacity=BUFSIZ;
   
    
    #if NODE_ISNULL==true
        if (*p!=NULL)
            return -1;
    #else
        free(*p);
    #endif
    
    #ifndef NDEBUG
        if (Node_Creat((void**)p,BUFSIZ)==false )
            return -1;
    #else
        Node_Creat((void**)p,BUFSIZ);
    #endif
    
    pt=*p;
    
    
    
    while ((c=fgetc(fp))!=end_signe)
    {
        *pt++=c;
        
        len=pt-*p;
        
        if (len==capacity-1)
        {
            #ifndef NDEBUG
                if (Node_Realloc((void**)p,sizeof (char )*(capacity+=BUFSIZ))==false )                
                    return -1;
            #else
                Node_Realloc((void**)p,sizeof (char )*(capacity+=BUFSIZ));
            #endif
                
        }
        
        pt=*p+len;
    }
    
    #ifndef NDEBUG
                if  (Node_Realloc((void**)p,sizeof (char )*len)==false )                
            return -1;
    #else
        Node_Realloc((void**)p,sizeof (char )*len);
    #endif
   
    *pt='\0';
    
    return len;
}

主函数.c

#include"Common.h"

COMP_CREAT(Comp_Int,int,NUM,MAX,0)
COMP_CREAT(Comp_Str,char*,STR,MIN,0)

COMP_CREAT(Comp_Float,float,NUM,MAX,1e-6)


int main()
{
    int i=0;
    int arr[]={5,6,1,2,3,4,7,9,8};
    float arr_f[]={1.52,0.64,3.16,2.57,99.9,0.005};
    char* str[]={"aaa","ddd","bbb","ccc"};
    char** ps=str;
    
    char* p=NULL;
    unsigned len=0;

 qsort(arr,sizeof(arr)/sizeof(*arr),sizeof(*arr),Comp_Int);
       
    for (i=0;i<sizeof(arr)/sizeof(*arr);++i)
        printf("%-4d",arr[i]);
    
    puts("");
    qsort(str,sizeof(str)/sizeof(*str),sizeof(*str),Comp_Str);
    
    while (ps-str<sizeof(str)/sizeof(*str))
       puts(*ps++);
   qsort(arr_f,sizeof(arr_f)/sizeof(*arr_f),sizeof(*arr_f),Comp_Float);
   
     for (i=0;i<sizeof(arr_f)/sizeof(*arr_f);++i)
        printf("%-8.4f",arr_f[i]);
        
    puts("");
    
    len=String_Get(stdin,&p,'\n');
    
    puts(p);
    printf("%u\n",len);
     
    Node_Free(&p);
    
    return 0;
}

效果如下~


嗯,或者有时间再更和完善一些功能~

[此贴子已经被作者于2017-11-21 18:02编辑过]

嗯,感觉这个泛型比较函数比我以前写所有基本数据类型包括大小比较的那些好看简单多了~

当然这个对于写结构体排序以及多重排序还是有局限性的~不过感觉好看很多了~

[此贴子已经被作者于2017-11-3 15:13编辑过]

之前的代码全是手机敲的~电脑运行不敢保证不会出现问题~还要经过一段时间DEBUG再说~

那个EPISILON是表示精度(最大误差)主要是小数不能直接和0比较,那里比起初发帖时改了一下,现在可以了~

一楼更新了个String_Get函数,功能类似于renkejun1942写的tostring函数,就是从堆中获取任意长度的字符串以及读取整个ASCII文件(还没有经过测试)的功能~有时间再DEBUG一下~

PS:感觉不使用assert判断也要对返回值进行判断,效率相差不大~不过这样分别#ifndef NDEBUG #else #end 感觉比较繁琐,看看或者我会考虑去掉NDEBUG判断这个功能~

[此贴子已经被作者于2017-11-4 15:42编辑过]

#ifndef NDBUG
# include <assert.h>
# MY_CHECK_COND(cond, ret)    do{ assert((cond)); }while(0)
#else
# MY_CHECK_COND(cond, ret)    do{ if (!(cond)) return ret; }while(0)
#endif

#define EARG    1000
#define ENOMEM    1001

int node_alloc_free(void **node, size_t size, int c)
{
    void *p;
    MY_CHECK_COND(node, -EARG);
    
    p = realloc(*node, size);
    if (p)
        *node = p;
    if (c >= 0 && *node)
        memset(*node, c, size);
    
    return p ? 0 : -ENOMEM;
}

int string_get(FILE *f, char **p, int eof)
{
    int err, i, n;
    char *q = NULL;
    
    MY_CHECK_COND(f && p, -EARG);
    
    for (i = n = 0; (c = fget(f)) != eof; ) {
        if (i + 2 > n) {
            err = node_alloc_free(&q, (n += BUFSIZ), 0);
            if (err && q)
                node_alloc_free(&q, 0, -1);
            MY_CHECK_COND(!err, err);
        }
        q[i++] = c;
    }
    
    if (i) {
        q[i] = 0;
        *p = q;
    }
    
    return i;
}

看上去很好的样子~
想不到竟然有人会好好消化这段代码~嗯,我选择收藏这段代码好好比对比对一下~而且感觉形式写得比我好多了,如果我不这么执着if的判断次数这些微不足道的细节或者会写得简洁好看很多~

嗯……学习了很多,吸取6楼的写法经验~打算重写学习进一步优化,拜谢了~

闲聊灌水:看来我还需要学习一下变量和函数命名规则~可以夸张点来说感觉一个好的变量名和函数名是成功写好程序的一半~

而且看了命名规则后发现6楼的代码应该是UNIX/LIUNX的环境下运行的吧(有兴趣的可以去具体了解一下)~

并且do{}while(0);这个用法比较独特且专业化~个人理解应该是对该段数据起到保护以及分立的作用~应该学习一下~

而且查过资料malloc通常需要进行memset来初始化的~感觉生成节点函数里面默认多加一个甚至几个if判断应该没啥问题~

预期重写代码应该会优化简洁很多~

[此贴子已经被作者于2017-11-5 00:00编辑过]

嗯,说做就做,学习了6楼的方法后重新写过然简洁方便阅读很多~
还去除了一些没啥意义的优化~使代码变得简洁清晰~
感觉这是一个成功的开始~

#ifndef _COMMON_H_
#define _COMMON_H_

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#ifdef __cplusplus
extern "C"
{
#endif

int Common_Node_Alloc(void**,size_t size);
int Common_Node_Free(void**);

int Comon_String_Get(FILE* fp,char** p,int eof);

#ifdef __cplusplus
}
#endif

#endif

Common.c

#include "Common.h"

#ifndef NDEBUG 
#include<assert.h>
#define CHECK_COND(cond,ret) do{assert(cond);}while (0)
#else
#define CHECK_COND(cond,ret) do{if (!(cond))return ret;}while(0)
#endif

#define EARG       1000
#define ENOMEN     1001
#define EINVAL     1002

int Common_Node_Alloc(void** node,size_t size)
{
    void* p=NULL;
    void* pt=*node;

    CHECK_COND(node, -EARG);

    p=realloc(*node,size);

    CHECK_COND(p,-ENOMEN);

    *node=p;

    if (!pt)
        memset(*node,0,size);

    return 0;
}

int Common_Node_Free(void** node)
{
    CHECK_COND(node, -EARG);

    if (*node==NULL)
        return -EINVAL;

    free(*node);
    *node=NULL;

    return 0;
}

int Comon_String_Get(FILE* fp,char** p,int userEof)
{
    int i=0;
    int n=0;
    int err=0;

    char c=0;

    char* q=NULL;

    CHECK_COND(fp&&p,-EARG);

    for (;(c=fgetc(fp))!=userEof&&c!=EOF;q[i++]=c)
        if (i+2>n)
        {
            err=Common_Node_Alloc((void** )&q,sizeof(char)*(n+=BUFSIZ));

            CHECK_COND(!err,err);

        }

    err=Common_Node_Alloc((void** )&q,sizeof(char)*(i+1));

    CHECK_COND(!err,err);

    q[i]='\0';
    *p=q;

    return i;
}

main.c

#include"Common.h"

int main()
{
    int* p=NULL;
    char* pch=NULL;
    int len=0;

    Common_Node_Alloc((void** )&p,sizeof(*p));

    *p=10001;
    printf("%d\n",*p);

    Common_Node_Free(&p);

    puts("请输入字符串:");
    len=Comon_String_Get(stdin,&pch,'\n');

    puts(pch);
    printf("字符串长度为:%d\n",len);
    Common_Node_Free((void**)&pch);

    return 0;
}

[此贴子已经被作者于2017-11-5 04:14编辑过]