精华内容
下载资源
问答
  • 我在stdlib.h中只找到了原型 请问他的实际实现代码在哪?
  • C语言stdlib.h下的qsort<快速排序>

    千次阅读 2017-03-14 20:47:37
    函数原型void qsort(void *__base, size_t __nel, size_t __width, int (* _Nonnull __compar)(const void *, const void *));实例#include <stdio.h> #include <stdlib.h> #include <string.h>// int 变量排序 in

    函数原型

    void qsort(void *__base, size_t __nel, size_t __width, 
                int (* _Nonnull __compar)(const void *, const void *));

    实例

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    // int 变量排序
    int compareInt(const void *a, const void *b) {
        return *(int *) a - *(int *) b;
    }
    
    int compareString(const void *a, const void *b) {
        return strcmp((char *) a, (char *) b);
    }
    
    int main() {
        const int len = 10;
        int a[len];
    
        // 数组排序
        for (int i = 0; i < len; ++i) {
            a[i] = rand() % 100; // [0, 99]
        }
        printf("排序前\n");
        for (int j = 0; j < len; ++j) {
            printf("%d\t", a[j]);
        }
        printf("\n");
        /*
         * 参数1:待排序数组首地址
         * 参数2:带排序的元素总个数 < const int len = 10 或者 #define LEN 10 >
         * 参数3:单个元素占用空间大小
         * 参数4:比较规则,a-b 从小到大,b-a 从大到小
         */
        qsort(a + 4, len - 4, sizeof(int), compareInt); // 前4个数不参与排序
        printf("排序后\n");
        for (int j = 0; j < len; ++j) {
            printf("%d\t", a[j]);
        }
        printf("\n");
    
        // 字符串排序
        char names[5][10] = {"WebStorm", "Pycharm", "IntelliJ", "CLion", "PhpStorm"};
        printf("排序前\n");
        for (int k = 0; k < 5; ++k) {
            printf("%10s\t", names[k]);
        }
        printf("\n");
        qsort(names, 5, 10 * sizeof(char), compareString);
        printf("排序后\n");
        for (int k = 0; k < 5; ++k) {
            printf("%10s\t", names[k]);
        }
        return 0;
    }
    排序前
    7   49  73  58  30  72  44  78  23  9   
    排序后
    7   49  73  58  9   23  30  44  72  78  
    排序前
      WebStorm     Pycharm    IntelliJ       CLion    PhpStorm  
    排序后
         CLion    IntelliJ    PhpStorm     Pycharm    WebStorm  
    展开全文
  • C语言-stdlib.h

    2019-11-30 21:52:41
    C语言-stdlib.h库 定义 :即standard library标准库头文件。stdlib.h里面定义了五种类型、一些宏和通用工具函数。 使用: #include <stdlib.h> 内部函数:malloc()、calloc()、realloc()、free()、system()...

    C语言-stdlib.h库 

     定义 :即standard library标准库头文件。stdlib.h里面定义了五种类型、一些宏和通用工具函数。

     使用: #include <stdlib.h>

     内部函数:malloc()、calloc()、realloc()、free()、system()、atoi()、atol()、rand()、srand()、exit()等

     
    展开全文
  • C语言stdio.h和stdlib.h

    千次阅读 2017-06-14 15:05:39
    stdlib.h里面定义了五种类型、一些宏和通用工具函数。类型例如size_t、wchar_t、div_t、ldiv_t和lldiv_t;宏例如EXIT_FAILURE、EXIT_SUCCESS、RAND_MAX和MB_CUR_MAX等等; 常用的函数如malloc()、calloc
    stdlib 头文件即standard library标准库头文件,包含了C、C++语言的最常用的系统函数。
    
    
    stdlib.h里面定义了五种类型、一些宏和通用工具函数。类型例如size_t、wchar_t、div_t、ldiv_t和lldiv_t;宏例如EXIT_FAILURE、EXIT_SUCCESS、RAND_MAX和MB_CUR_MAX等等;
    
    
    常用的函数如malloc()、calloc()、realloc()、free()、system()、atoi()、atol()、rand()、srand()、exit()等等。 
    具体的内容你自己可以打开编译器的include目录里面的stdlib.h头文件看看。
    
    stdio 就是指 “standard buffered input&output" 意思就是说带缓冲的标准输入输出!
    stdlib里的是常用系统函数,跟系统调用相关的,比如内存申请malloc和释放free;
    
    stdio是标准io函数,比如printf和scanf函数。
    
    
    展开全文
  • C语言stdlib.h操作

    千次阅读 2016-10-21 15:27:00
    C语言stdlib.h操作 下面是头文件 stdlib.h 中定义的变量类型: 1 size_t 这是无符号整数类型,它是 sizeof 关键字的结果。 2 wchar_t 这是一个宽字符常量大小的整数类型。 3 div_t 这是 div 函数返回的结构。 4 ...
    C语言库stdlib.h操作
    下面是头文件 stdlib.h 中定义的变量类型:
    1	size_t    这是无符号整数类型,它是 sizeof 关键字的结果。
    2	wchar_t   这是一个宽字符常量大小的整数类型。
    3	div_t     这是 div 函数返回的结构。
    4	ldiv_t    这是 ldiv 函数返回的结构。
    
    
    下面是头文件 stdlib.h 中定义的宏:
    1	NULL  这个宏是一个空指针常量的值。
    2	EXIT_FAILURE    这是 exit 函数失败时要返回的值。
    3	EXIT_SUCCESS    这是 exit 函数成功时要返回的值。
    4	RAND_MAX        这个宏是 rand 函数返回的最大值。
    5	MB_CUR_MAX      这个宏表示在多字节字符集中的最大字符数,不能大于 MB_LEN_MAX。
    
    
    
    1. atof(str)     String-->Double   会依次遍历字符串  直到碰到字母停止 然后给出遍历的数字字符 
    double atof(const char *str) 把参数 str 所指向的字符串转换为一个浮点数(类型为 double 型)
    函数返回转换后的双精度浮点数,如果没有执行有效的转换,则返回零(0.0)
    
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    
    int main()
    {
       float val;
       char str[20];
       
       strcpy(str, "956843");
       val = atof(str);
       printf("字符串值 = %s, 浮点值 = %f\n", str, val);
    
    
       strcpy(str, "123abc"); //遇到了字符a停止遍历  遍历为  123.000000
       val = atof(str);
       printf("字符串值 = %s, 浮点值 = %f\n", str, val);
       
       strcpy(str, "123.321");
       val = atof(str);
       printf("字符串值 = %s, 浮点值 = %f\n", str, val);
    
    
       return 0;
    }
    打印结果:
    字符串值 = 956843, 浮点值 = 956843.000000
    字符串值 = 123abc, 浮点值 = 123.000000
    字符串值 = 123.321, 浮点值 = 123.320999
    
    
    
    2.atoi(str)   会依次遍历字符串  直到碰到字母停止 然后给出遍历的数字字符 
    int atoi(const char *str) 把参数 str 所指向的字符串转换为一个整数(类型为 int 型)。
    该函数返回转换后的长整数,如果没有执行有效的转换,则返回零。
    
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    
    int main()
    {
       int val;
       char str[20];
       
       strcpy(str, "654321");
       val = atoi(str);
       printf("字符串值 = %s, 整型值 = %d\n", str, val);
    
    
       strcpy(str, "1256a4");
       val = atoi(str);
       printf("字符串值 = %s, 整型值 = %d\n", str, val);
    
    
       strcpy(str, "a123");
       val = atoi(str);
       printf("字符串值 = %s, 整型值 = %d\n", str, val);
       
       return 0;
    }
    打印结果:
    字符串值 = 654321, 整型值 = 654321
    字符串值 = 1256a4, 整型值 = 1256
    字符串值 = a123, 整型值 = 0
    
    
    
    3.atol(str)
    long int atol(const char *str) 把参数 str 所指向的字符串转换为一个长整数(类型为 long int 型)
    该函数返回转换后的长整数,如果没有执行有效的转换,则返回零
    
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    
    int main()
    {
       long val;
       char str[20];
       
       strcpy(str, "98993489");
       val = atol(str);
       printf("字符串值 = %s, 长整型值 = %ld\n", str, val);
    
    
       strcpy(str, "96avda1"); // 遍历为96
       val = atol(str);
       printf("字符串值 = %s, 长整型值 = %ld\n", str, val);
    
    
       strcpy(str, "a*fai");
       val = atol(str);
       printf("字符串值 = %s, 长整型值 = %ld\n", str, val);
       
       return 0;
    }
    打印结果:
    字符串值 = 98993489, 长整型值 = 98993489
    字符串值 = 96avda1, 长整型值 = 96
    字符串值 = a*fai, 长整型值 = 0
    
    
    
    4.double strtod(const char *str, char **endptr)    Str --> Double  而且能获得数字之后的字符串  假如str中存在非数字字符的话
    double strtod(const char *str, char **endptr) 把参数 str 所指向的字符串转换为一个浮点数(类型为 double 型)。
    如果 endptr 不为空 则指向转换中最后一个字符后的字符的指针会存储在 endptr 引用的位置
    str -- 要转换为双精度浮点数的字符串。
    endptr -- 对类型为 char* 的对象的引用,其值由函数设置为 str 中数值后的下一个字符。
    该函数返回转换后的双精度浮点数,如果没有执行有效的转换,则返回零(0.0)
    
    
    #include <stdio.h>
    #include <stdlib.h>
    
    
    int main()
    {
      char str[30] = "20.30300 This is test";
       char *ptr;
       double ret;
    
    
       ret = strtod(str, &ptr);
       printf("str 数字(double)是 %lf\n", ret);
       printf("str 字符串部分是 |%s|\n", ptr);
    
    
       char str1[30] = "18.032561A130A98 hello world";
       ret = strtod(str1, &ptr);
       printf("str1 数字(double)是 %lf\n", ret);
       printf("str1 字符串部分是 |%s|", ptr);
       
       char str2[30] = "3.21123456789";
       ret = strtod(str2, &ptr);
       printf("str2 数字(double)是 %lf\n", ret);
       printf("str2 字符串部分是 |%s|", ptr);
       return 0;
    }
    打印结果:
    str 数字(double)是 20.303000
    str 字符串部分是 | This is test|
    str1 数字(double)是 18.032561
    str1 字符串部分是 |A130A98 hello world|
    str2 数字(double)是 3.211235
    str2 字符串部分是 ||
    
    
    
    5.long int strtol(const char *str, char **endptr, int base) 
    long int strtol(const char *str, char **endptr, int base)  str--->long int
    把参数 str 所指向的字符串根据给定的 base 转换为一个长整数(类型为 long int 型),base 必须介于 2 和 36(包含)之间,或者是特殊值 0
    str -- 要转换为长整数的字符串。
    endptr -- 对类型为 char* 的对象的引用,其值由函数设置为 str 中数值后的下一个字符
    base -- 基数,必须介于 2 和 36(包含)之间,或者是特殊值 0    base可以理解为进制的意思 代表str中的字符为多少进制
    
    
    #include <stdio.h>
    #include <stdlib.h>
    
    
    int main()
    {
       char str[30] = "123456789 9hello8 world";
       char *ptr;
       long ret;
    
    
       ret = strtol(str, &ptr, 10);
       printf("str 数字(无符号长整数)是 %ld\n", ret);
       printf("str 字符串部分是 |%s|\n", ptr);
    
    
    
    
       char str1[30] = "11 str";
       ret = strtol(str1, &ptr, 9);
       printf("str1数字(无符号长整数)是 %ld\n", ret);  // 以9进制解析 11 结果为10 正确
       printf("str1字符串部分是 |%s|\n", ptr);
    
    
       char str2[30] = "32 str";
       ret = strtol(str2, &ptr, 0);
       printf("str2 数字(无符号长整数)是 %ld\n", ret);
       printf("str2 字符串部分是 |%s|\n", ptr);
       return 0;
    }
    打印结果:
    str 数字(无符号长整数)是 123456789
    str 字符串部分是 | 9hello8 world|
    str1数字(无符号长整数)是 10
    str1字符串部分是 | str|
    str2 数字(无符号长整数)是 32
    str2 字符串部分是 | str|
    
    
    
    6.strtoul(const char *str, char **endptr, int base)        str---> unsigned long int 
    unsigned long int strtoul(const char *str, char **endptr, int base) 把参数 str 所指向的字符串
    根据给定的 base 转换为一个无符号长整数(类型为 unsigned long int 型),base 必须介于 2 和 36(包含)之间,或者是特殊值 0
    base -- 基数,必须介于 2 和 36(包含)之间,或者是特殊值 0    base可以理解为进制的意思 代表str中的字符为多少进制
    
    
    #include <stdio.h>
    #include <stdlib.h>
    
    
    int main()
    {
       char str[30] = "315 A315";
       char *ptr;
       long ret;
    
    
       ret = strtoul(str, &ptr, 10);
       printf("数字(无符号长整数)是 %lu\n", ret);
       printf("字符串部分是 |%s|", ptr);
    
    
       char str1[30] = "415 A305";
       ret = strtoul(str1, &ptr, 0);
       printf("数字(无符号长整数)是 %lu\n", ret);
       printf("字符串部分是 |%s|", ptr);
       
       char str2[30] = "1111 A32647";  
       ret = strtoul(str2, &ptr, 2);  // 已二进制的形式解析 
       printf("数字(无符号长整数)是 %lu\n", ret);    //打印出15 符合1111 = 15
       printf("字符串部分是 |%s|", ptr);
       
       return 0;
    }
    打印结果:
    数字(无符号长整数)是 315
    字符串部分是 | A315|数字(无符号长整数)是 415
    字符串部分是 | A305|数字(无符号长整数)是 15    
    字符串部分是 | A32647|
    
    
    
    7.calloc(size_t nitems, size_t size)
    void *calloc(size_t nitems, size_t size) 分配所需的内存空间,并返回一个指向它的指针。
    malloc 和 calloc 之间的不同点是,malloc 不会设置内存为零,而 calloc 会设置分配的内存为零
    nitems -- 要被分配的元素个数。
    size -- 元素的大小
    
    
    #include <stdio.h>
    #include <stdlib.h>
    
    
    int main()
    {
       int i, n;
       int *a;
    
    
       printf("要输入的元素个数:");
       scanf("%d",&n);
    
    
       a = (int*)calloc(n, sizeof(int)); // 在内存中创建两个整型数值 空间
       printf("输入 %d 个数字:\n",n);
       for( i=0 ; i < n ; i++ ) 
       {
          scanf("%d",&a[i]);
       }
    
    
       printf("输入的数字为:");
       for( i=0 ; i < n ; i++ ) {
          printf("%d ",a[i]);
       }
       
       return 0;
    }
    打印结果:
    要输入的元素个数:2
    输入 2 个数字:
    123
    456
    输入的数字为:123 456
    
    
    
    8. void free(void *ptr)
    void free(void *ptr) 释放之前调用 calloc、malloc 或 realloc 所分配的内存空间。
    ptr -- 指针指向一个要释放内存的内存块,该内存块之前是通过调用 malloc、calloc 或 realloc 进行分配内存的。
    如果传递的参数是一个空指针,则不会执行任何动作。 该函数不返回任何值。
    
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    
    int main()
    {
       char *str;
    
    
       /* 最初的内存分配 */
       str = (char *) malloc(15); // 分配15个字节空间   malloc 不会设置内存为零  并把该内存地址赋值给str 
       strcpy(str, "Hello World"); 
       printf("String = %s,  Address = %u\n", str, str);
    
    
       /* 重新分配内存 */
       str = (char *) realloc(str, 25); // 把 str的内存地址重新分配为 25 个字节地址
       strcat(str, "123456789");
       printf("String = %s,  Address = %u\n", str, str);
    
    
       /* 释放已分配的内存 */
       free(str); 
       
       return(0);
    }
    打印结果:
    String = Hello World,  Address = 7304208
    String = Hello World123456789,  Address = 7304208
    
    
    
    9.malloc(size_t size)  分配内存空间  字节数
    void *malloc(size_t size) 分配所需的内存空间,并返回一个指向它的指针
    size -- 内存块的大小,以字节为单位。
    该函数返回一个指针 ,指向已分配大小的内存。如果请求失败,则返回 NULL。
    
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    
    int main()
    {
       char *str;
    
    
       /* 最初的内存分配 */
       str = (char *) malloc(15); //分配15个内存地址
       strcpy(str, "12345678901234");
       printf("String = %s,  Address = %u\n", str, str);
    
    
       /* 重新分配内存 */
       str = (char *) realloc(str, 25);
       strcat(str, "123456");
       printf("String = %s,  Address = %u\n", str, str);
    
    
       free(str);
       
       return(0);
    }
    打印结果:
    String = 12345678901234,  Address = 7042064
    String = 12345678901234123456,  Address = 7042064
    
    
    
    10.realloc(void *ptr, size_t size) 
    void *realloc(void *ptr, size_t size) 尝试重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小
    
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    int main()
    {
       char *str;
    
    
       /* 最初的内存分配 */
       str = (char *) malloc(10);
       strcpy(str, "123456789");
       printf("String = %s,  Address = %u\n", str, str);
    
    
       /* 重新分配内存 */
       str = (char *) realloc(str, 25);  // 重新分配
       strcat(str, "123456789");
       printf("String = %s,  Address = %u\n", str, str);
    
    
       free(str);
       
       return 0;
    }
    打印结果:
    String = 123456789,  Address = 7435280
    String = 123456789123456789,  Address = 7435280
    


    11. abort() 中止程序执行
    void abort(void) 中止程序执行,直接从调用的地方跳出
    #include <stdio.h>
    #include <stdlib.h>
    
    int main ()
    {
       FILE *fp;
       
       printf("准备打开 nofile.txt\n");
       fp = fopen( "nofile.txt","r" );
       if(fp == NULL)
       {
          printf("准备终止程序\n");
          abort();   //直接跳出    XXXX已停止工作
          printf("已经终止程序\n");  //该语句永远不能打印
       }
       printf("准备关闭 nofile.txt\n");
       fclose(fp);
       
       return 0;
    }
    打印结果:
    准备打开 nofile.txt
    准备终止程序   
    -----------------------------程序结束
    
    
    
    12. int atexit(void (*func)(void))
    int atexit(void (*func)(void)) 当程序正常终止时,调用指定的函数 func。
    您可以在任何地方注册你的终止函数,但它会在程序终止的时候被调用
    func -- 在程序终止时被调用的函数
    如果函数成功注册,则该函数返回零,否则返回一个非零值
    
    #include <stdio.h>
    #include <stdlib.h>
    
    void functionA ()
    {
       printf("这是函数A\n");
    }
    
    int main ()
    {
       /* 注册终止函数 */
       int ret = atexit(functionA );
       
       printf("ret = %d  启动主程序...\n",ret);
    
       printf("退出主程序...\n");
    
       return 0;  // 在返回前 调用
    }
    打印结果:
    ret = 0  启动主程序...
    退出主程序...
    这是函数A
    
    
    
    
    13.
    void exit(int status) 立即终止调用进程。任何属于该进程的打开的文件描述符都会被关闭
    ,且会向父进程发送一个 SIGCHLD 信号
    status -- 传递给父进程的状态值。
    该函数不返回值
    
    #include <stdio.h>
    #include <stdlib.h>
    
    int main ()
    {
       printf("程序的开头....\n");
       
       printf("退出程序....\n");
       exit(0);   // 0 是传递给父进程的信号标志
    
       printf("程序的结尾....\n");
    
       return 0;
    }
    打印结果:
    程序的开头....
    退出程序....
    
    
    
    
    14.getenv(str)   getenv()用来取得参数envvar环境变量的内容 envvar为环境变量的名称,如果该变量存在则会返回指向该内容的指针
    char *getenv(const char *name) 搜索 name 所指向的环境字符串,并返回相关的值给字符串
    name -- 包含被请求变量名称的 C 字符串
    该函数返回一个以 null 结尾的字符串,该字符串为被请求环境变量的值。如果该环境变量不存在,则返回 NULL
    
    #include <stdio.h>
    #include <stdlib.h>
    
    int main ()
    {
       printf("PATH : %s\n", getenv("PATH"));
       printf("HOME : %s\n", getenv("HOME"));
       printf("ROOT : %s\n", getenv("ROOT"));
       printf("COMSPEC : %s\n", getenv("COMSPEC"));
       printf("LIB : %s\n", getenv("LIB"));
       printf("USER : %s\n", getenv("USER"));
       return 0;
    }
    
    打印结果:
    PATH : C:\Program Files (x86)\Dev-Cpp\MinGW64\bin;C:\Users\zwx320975\Desktop\IT
    Win+R自定义快捷方式\129-nTurn\129-nTurn\Goto;C:\Program Files (x86)\Common File
    \NetSarang;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\S
    stem32\WindowsPowerShell\v1.0\;C:\Program Files (x86)\Citrix\ICAService\;C:\Pro
    ram Files (x86)\Citrix\System32\;C:\Program Files\TortoiseSVN\bin;C:\Program Fi
    es\Java\jdk1.5.0_20\bin;C:\Program Files\Java\jdk1.5.0_20\jre;C:\Program Files
    x86)\Windows Kits\8.1\Windows Performance Toolkit\;C:\Program Files\Microsoft S
    L Server\110\Tools\Binn\;C:\Program Files (x86)\Microsoft SDKs\TypeScript\1.0\;
    :\Program Files\Microsoft SQL Server\120\Tools\Binn\
    HOME : (null)
    ROOT : (null)
    COMSPEC : C:\Windows\system32\cmd.exe
    LIB : (null)
    USER : (null)
    
    
    
    
    15. system(str command)  把 command 指定的命令名称或程序名称传给要被命令处理器执行的主机环境
    int system(const char *command) 把 command 指定的命令名称或程序名称传给要被命令处理器执行的主机环境,并在命令完成后返回
    command -- 包含被请求变量名称的 C 字符串
    如果发生错误,则返回值为 -1,否则返回命令的状态
    
    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    
    int main ()
    {
       char command[50];
    
       strcpy( command, "dir" );   //windows
       //strcpy( command, "ls -l" );   //Linux
       system(command);
    
       return 0;
    } 
    打印结果:
     D:\TEMP 的目录
    
    2016/10/24  14:53    <DIR>          .
    2016/10/24  14:53    <DIR>          ..
    2016/10/20  15:40               241 1.cpp
    2016/10/20  15:27           127,205 1.exe
    2016/10/20  18:14               254 2.cpp
    2016/10/20  18:14           370,513 2.exe
    2016/10/21  17:14             1,461 3.cpp
    2016/10/21  17:12           369,825 3.exe
    2016/10/24  14:53               233 4.cpp
    2016/10/24  14:53           370,476 4.exe
    2015/11/09  17:53    <DIR>          frameworks
    2015/11/04  19:50    <DIR>          HwCamera
    2015/11/04  20:04    <DIR>          HwGallery2
    2015/12/02  15:55    <DIR>          HwSoundRecorder
    2016/10/20  14:28               926 未命名1.cpp
    2016/10/20  14:29           372,245 未命名1.exe
    2016/10/20  15:06               226 未命名2.rc
                  11 个文件      1,613,605 字节
                   6 个目录  2,545,360,896 可用字节
    			   
    
    
    		   
    			   
    16. void *bsearch(const void *key, const void *base, size_t nitems, size_t size, int (*compar)(const void *, const void *)) 执行二分查找
    void *bsearch(const void *key, const void *base, size_t nitems, size_t size, int (*compar)(const void *, const void *))
    nitems 对象的数组执行二分查找,base 指向进行查找的数组,key 指向要查找的元素,
    size 指定数组中每个元素的大小。数组的内容应根据 compar 所对应的比较函数升序排序
    key -- 指向要查找的元素的指针,类型转换为 void*。  当前需要在数组中查找的Item的指针
    base -- 指向进行查找的数组的第一个对象的指针,类型转换为 void*。  数组的头指针
    nitems -- base 所指向的数组中元素的个数。  数组的Length
    size -- 数组中每个元素的大小,以字节为单位。 每个Item的内存大小
    compar -- 用来比较两个元素的函数。
    如果查找成功,该函数返回一个指向数组中匹配元素的指针,否则返回空NULL指针
    
    #include <stdio.h>
    #include <stdlib.h>
    
    
    int cmpfunc(const void * a, const void * b)
    {
       return ( *(int*)a - *(int*)b );
    }
    
    int values[] = { 5, 20, 29, 32, 63 };
    
    int main ()
    {
       int *item;
       int key = 64;  // 打印 Item = NULL  could not be found
       int key1 = 32;  // 打印 Found item = 32
       /* 使用 bsearch() 在数组中查找值 32 */
       item = (int*) bsearch (&key, values, 5, sizeof (int), cmpfunc); //查找到  就返回对应元素的指针
       if( item != NULL ) 
       {
          printf("Found item = %d\n", *item);
       }
       else 
       {
          printf("Item = NULL  could not be found\n");
       }
       
       
       item = (int*) bsearch (&key1, values, 5, sizeof (int), cmpfunc); //查找到  就返回对应元素的指针
       if( item != NULL ) 
       {
          printf("Found item = %d\n", *item);
       }
       else 
       {
          printf("Item = NULL  could not be found\n");
       }
     
       return 0;
    }
    打印结果:
    Item = NULL  could not be found
    Found item = 32
    
    
    
    
    17.void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void*)) 对数组进行排序
    base -- 指向要排序的数组的第一个元素的指针。
    nitems -- 由 base 指向的数组中元素的个数。
    size -- 数组中每个元素的大小,以字节为单位。
    compar -- 用来比较两个元素的函数。
    该函数不返回任何值。
    
    
    #include <stdio.h>
    #include <stdlib.h>
    
    int values[] = { 88, 56, 100, 2, 25 };
    
    int cmpfunc (const void * a, const void * b)
    {
       return ( *(int*)a - *(int*)b );
    }
    
    int main()
    {
       int n;
    
       printf("排序之前的列表:\n");
       for( n = 0 ; n < 5; n++ ) {
          printf("%d ", values[n]);
       }
    
       qsort(values, 5, sizeof(int), cmpfunc);
    
       printf("\n排序之后的列表:\n");
       for( n = 0 ; n < 5; n++ ) {
          printf("%d ", values[n]);
       }
      
      return 0;
    }
    
    打印结果:
    排序之前的列表:
    88 56 100 2 25
    排序之后的列表:
    2 25 56 88 100
    
    
    
    18.int abs(int x) 返回 x 的绝对值
    x -- 完整的值
    该函数返回 x 的绝对值
    
    #include <stdio.h>
    #include <stdlib.h>
    
    int main ()
    {
       int a, b;
    
       a = abs(100);
       printf("a 的值 = %d\n", a);
    
       b = abs(-200);
       printf("b 的值 = %d\n", b);
       
       return 0;
    }
    打印结果:
    a 的值 = 100
    b 的值 = 200
    
    
    
    
    19.div_t div(int numer, int denom)   除法
    div_t div(int numer, int denom) 把 numer(分子)除以 denom(分母)
    
    该函数返回定义在 <cstdlib> 中的结构中的值,该结构有两个成员,如 div_t:int quot  商; int rem  余数;。
    
    
    #include <stdio.h>
    #include <stdlib.h>
    
    int main()
    {
       div_t output;
    
       output = div(27, 4);
       printf("(27/ 4) 的商  = %d\n", output.quot);
       printf("(27/4) 的余数 = %d\n", output.rem);
    
       output = div(27, 3);
       printf("(27/ 3) 的商 = %d\n", output.quot);  // 商
       printf("(27/3) 的余数 = %d\n", output.rem);  // 余数
    
       return 0;
    }
    打印结果:
    (27/ 4) 的商  = 6
    (27/4) 的余数 = 3
    (27/ 3) 的商 = 9
    (27/3) 的余数 = 0
    
    
    
    
    20. labs(long int x)  返回长整型的绝对值
    long int labs(long int x) 返回 x 的绝对值
    该函数返回 x 的绝对值。
    
    #include <stdio.h>
    #include <stdlib.h>
    
    int main ()
    {
       long int a,b;
    
       a = labs(65987L);
       printf("a 的值 = %ld\n", a);
    
       b = labs(-1005090L);
       printf("b 的值 = %ld\n", b);
       
       return 0;
    }
    打印结果:
    a 的值 = 65987
    b 的值 = 1005090
    
    
    
    21.div(long int numer, long int denom)  长整型
    div_t div(long int numer, long int denom) 把 numer(分子)除以 denom(分母)
    该函数返回定义在 <cstdlib> 中的结构中的值, 该结构有两个成员,如  ldiv_t:long quot 商; long rem 余数;。
    
    #include <stdio.h>
    #include <stdlib.h>
    
    int main ()
    {
       ldiv_t output;
    
       output = ldiv(100000L, 30000L);
    
       printf("商 = %ld\n", output.quot);
    
       printf("余数 = %ld\n", output.rem);
       
       return 0;
    }
    打印结果:
    商 = 3
    余数 = 10000
    
    
    
    
    22.  int rand(void)   得到随机数
    int rand(void) 返回一个范围在 0 到 RAND_MAX 之间的伪随机数
    RAND_MAX 是一个常量,它的默认值在不同的实现中会有所不同,但是值至少是 32767
    该函数返回一个范围在 0 到 RAND_MAX 之间的整数值。
    
    #include <stdio.h>
    #include <stdlib.h>
    
    int main()
    {
       int i, n;
       time_t t;
       
       n = 5;
       
       /* 初始化随机数发生器 */
       srand((unsigned) time(&t));
    
       /* 输出 0 到 49 之间的 5 个随机数 */
       for( i = 0 ; i < n ; i++ ) {
          printf("%d\n", rand() % 50);
       }
       
      return 0;
    }
    打印结果:
    20
    1
    3
    11
    38
    
    
    
    
    23.void srand(unsigned int seed)
    void srand(unsigned int seed) 播种由函数 rand 使用的随机数发生器
    seed -- 这是一个整型值,用于伪随机数生成算法播种。
    该函数不返回任何值
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
    int main()
    {
       int i, n;
       time_t t;
       
       n = 5;
       
       /* 初始化随机数发生器 */
       srand((unsigned) time(&t)); //初始化随机数发生器
    
       /* 输出 0 到 50 之间的 5 个随机数 */
       for( i = 0 ; i < n ; i++ ) {
          printf("%d\n", rand() % 50);
       }
       
      return 0;
    }
    打印结果:
    13
    11
    49
    23
    43
    
    
    
    
    24.mblen
    int mblen(const char *str, size_t n) 返回参数 str 所指向的多字节字符的长度
    str -- 指向多字节字符的第一个字节的指针。
    n -- 要检查的字符长度的最大字节数。
    如果识别了一个非空宽字符,mblen() 函数返回 str 开始的多字节序列解析的字节数。
    如果识别了一个空宽字符,则返回 0。
    如果识别了一个无效的多字节序列,或者不能解析一个完整的多字节字符,则返回 -1
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    int main()
    {
       int len;
       char *pmbnull  = NULL;
       char *pmb = (char *)malloc( MB_CUR_MAX );
       wchar_t *pwc = L"Hi";
       wchar_t *pwcs = (wchar_t *)malloc( sizeof( wchar_t ));
    
    
       
       len = mblen( pmb, MB_CUR_MAX );
       printf( "多字节字符 %x 的字节长度:%u\n", pmb, len );
       
       pmb = NULL;
       
       len = mblen( pmb, MB_CUR_MAX );
       printf( "多字节字符 %x 的字节长度:%u\n", pmb, len );
       
       return 0;
    }
    打印结果:
    多字节字符 717410 (地址)的字节长度:4294967295 (字节大小)
    多字节字符 0 的字节长度:0
    
    
    
    25.mbstowcs
    size_t mbstowcs(schar_t *pwcs, const char *str, size_t n) 把参数 str 所指向的多字节字符的字符串转换为参数 pwcs 所指向的数组
    pwcs -- 指向一个 wchar_t 元素的数组,数组长度足以存储一个最大字符长度的宽字符串。
    str -- 要被转换的多字节字符字符串。
    n -- 要被转换的最大字符数。
    该函数返回转换的字符数,不包括结尾的空字符。如果遇到一个无效的多字节字符,则返回 -1 值。
    
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    int main()
    {
       int len;
       char *pmbnull  = NULL;
       char *pmb = (char *)malloc( MB_CUR_MAX );
       wchar_t *pwc = L"Hi";
       wchar_t *pwcs = (wchar_t *)malloc( sizeof( wchar_t ));
    
       printf("转换为多字节字符串\n");
       len = wcstombs( pmb, pwc, MB_CUR_MAX);
       printf("被转换的字符 %d\n", len);
       printf("第一个多字节字符的十六进制值:%#.4x\n", pmb);
       
       printf("转换回宽字符字符串\n");
       len = mbstowcs( pwcs, pmb, MB_CUR_MAX);
       printf("被转换的字符 %d\n", len);
       printf("第一个宽字符的十六进制值:%#.4x\n\n", pwcs);
       
       return 0;
    }
    打印结果:
    转换为多字节字符串
    被转换的字符 1
    第一个多字节字符的十六进制值:0x6f7410
    转换回宽字符字符串
    被转换的字符 1
    第一个宽字符的十六进制值:0x6f7430
    
    
    


    展开全文
  • C语言标准库stdlib.h

    万次阅读 多人点赞 2020-02-10 18:37:56
    stdlib.h&gt; 中的 宏、函数、数据类型 在最后给出一个实例程序,尽可能运用到所有函数 宏 EXIT_SUCCESS 和 EXIT_FAILURE exit函数成功退出和失败的返回值 #define EXIT_SUCCESS 0 #define EXIT_FAILURE 1 RAND...
  • C语言头文件stdlib.h里面有什么函数

    千次阅读 2018-10-28 16:40:53
    主要含有的内容方向: A.字符串转换 B. 随机数 C.内存管理 D.与环境的接口 E.查找与排序 F.整数运算 G....(1)关于 stdio.h 和 stdlib.h 包含的函数 ...(2)C语言库函数stdlib.h里面都包含什么 https:/...
  • C语言stdlib库(#include<stdlib.h>)

    千次阅读 2017-09-05 09:44:48
    stdlib.h中头文件定义了四个变量类型,用于执行一般函数的几个宏和各类函数。 库变量 以下是在头文件stdlib.h中定义的变量类型: S.N. 变量和说明 1 size_t  这是一个无符号整数类型的sizeof关键字的...
  • c语言头文件stdlib.h的详细介绍

    千次阅读 多人点赞 2017-09-12 20:06:41
    stdlib.h里面定义了五种类型、一些宏和通用工具函数。 类型例如size_t、wchar_t、div_t、ldiv_t和lldiv_t; 宏例如EXIT_FAILURE、EXIT_SUCCESS、RAND_MAX和MB_CUR_MAX等等; 常用的函数如malloc()、calloc()、...
  • rand() (这个函数我之前关于数组的博客写到了https://blog.csdn.net/viafcccy/article/details/83960390) srand(unsigned t)埋下时间种子 实例:int random1;  srand(time(0));//等效于srand(time(null));...
  • C语言中的stdlib.h头文件

    千次阅读 2019-03-07 10:09:28
    stdlib 头文件stdlib 头文件的介绍stdlib.h里面定义了五种类型、一些宏和通用工具函数常用的函数 stdlib 头文件的介绍 stdlib 头文件即standard library标准库头文件 stdlib 头文件里包含了C、C++语言的最常用的...
  • stdlib.h常用函数包括 int abs (int x); int atexit (atexit_t func); double atof (const char *s); int atoi (const char *s); long atol (const char *s); void * bsearch(const void *key, const void *...
  • 转自: http://blog.csdn.net/ybsun2010/article/details/24843835 stdlib.h 1. stdlib.h  stdlib 头文件即standard library标准库头文件 ...该文件包含了C语言标准库函数的定义 ...stdlib.h里面定

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,133
精华内容 8,053
关键字:

c语言stdlib.h

c语言 订阅