精华内容
下载资源
问答
  • malloc 全称为 memory allocation 存储分配。
    malloc 全称为 memory allocation 存储分配。吐舌头
    展开全文
  • 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头文件

    千次阅读 2019-03-07 10:09:28
    stdlib 头文件stdlib 头文件的介绍stdlib.h...stdlib 头文件里包含了C、C++语言的最常用的系统函数, 该文件包含了的C语言标准库函数的定义 stdlib.h里面定义了五种类型、一些宏和通用工具函数 类型: 例如 size_...

    stdlib 头文件的介绍

    stdlib 头文件即standard library标准库头文件

    stdlib 头文件里包含了C、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头文件看看。

    展开全文
  • C语言中stdlib头文件解析

    千次阅读 多人点赞 2018-01-14 14:06:39
    stdlib 头文件即standard library(标准库)头文件,里面包含了C、C++语言的最常用的系统函数。包括动态内存管理、随机数生成、与环境之间的通信、整数运算、搜索、排序及转换等。 stdlib .h 头文件定义了四个变量...

    stdlib 头文件即standard library(标准库)头文件,里面包含了C、C++语言的最常用的系统函数。包括动态内存管理、随机数生成、与环境之间的通信、整数运算、搜索、排序及转换等。
    stdlib .h 头文件定义了四个变量类型、五个宏和各种通用工具函数。

    4个变量:

    size_t
    wchar_t(一个宽字符常量大小的整数类型)
    div_t(div函数返回的结构)
    ldiv_t(ldiv 函数返回的结构)。
    

    5个宏:

    NULL;
    EXIT_FAILURE;   exit 函数失败时要返回的值
    EXIT_SUCCESS;   exit 函数成功时要返回的值
    RAND_MAX;       rand 函数返回的最大值;
    MB_CUR_MAX  在多字节字符集中的最大字符数
    

    一些主要的函数

    •atof函数

    函数原型:double atof (const char* str);
    函数描述:把参数 str 所指向的字符串转换为一个浮点数。
    函数返回:函数返回转换后的双精度浮点数,如果没有执行有效的转换,则返回零(0.0)。
    特点:
    1:函数会不理会字符串开始之后的空格,直到遇到第一个有效字符,从第一个有效字符开始,到最后一个有效字符为止,函数会将这段字符转换为浮点数。最后一个有效字符之后的字符不会影响该函数。
    2:对于C90,有效字符包括以下条件:可以以+-字符作为字符串的开始;字符串中可以出现(不超过)一个.符;可以出现表示指数形式的E或e字符,且其后可以跟一个有效字符串。
    3:对于C99/C11,除C90的条件外,还支持0x/0X前缀,INF,NAN等。

    •atoi函数

    函数原型:int atoi(const char *str);
    函数描述:把参数 str 所指向的字符串转换为一个整数。
    函数返回:返回转换后的长整数,如果没有执行有效的转换,则返回零。
    特点:
    1:函数会忽略字符串刚开始的空格,直到遇到第一个有效字符。
    2:+和-位于第一个字符是被认为是有效字符。最后一个有效字符之后的字符不会影响该函数。
    3:若转换后的数据长度超出int所表示的最大范围,将产生未定义的行为。

    •atol函数

    函数原型:long int atol(const char *str);
    函数描述:把参数 str 所指向的字符串转换为一个长整数(类型为 long int 型)。
    函数返回:返回转换后的长整数,如果没有执行有效的转换,则返回零。
    特点:与atoi一致。

    •strtod函数

    函数原型:double strtod(const char *str, char **endptr);
    函数描述:把参数 str 所指向的字符串转换为一个浮点数(类型为 double 型)。
    函数返回:返回转换后的双精度浮点数,如果没有执行有效的转换,则返回零(0.0)。
    特点:
    1:函数会忽略字符串刚开始的空格,直到遇到第一个有效字符。
    2:如果 endptr 不为空,则它指向转换中最后一个有效字符后的字符所在的地址。
    3:实际使用中常将endptr设为null,表示不关注无效字符。

    •strtol函数

    函数原型:long int strtol(const char *str, char **endptr, int base);
    函数描述:把参数 str 所指向的字符串根据给定的 base 转换为一个长整数,base 必须介于 2 和 36(包含)之间,或者是特殊值 0。
    函数返回:函数返回转换后的长整数,如果没有执行有效的转换,则返回一个零值。
    特点:
    1.对于base,若base为0,则要求:首字母可以是(+/-),若首字母不是0或0x/0X,则必须是十进制的其他字符,且按照10进制进行转换;若首字母是0或0x/0X,则分别按照8进制或16进制转换,开始的0及x/X会被忽略,在此过程中,超出8进制和16进制的字符会被认为是无效字符(如0912会被转化为0,因为会按照8进制来转换,9被认为是无效字符)。
    2:若为36进制,则为从0~z/Z。
    3:其余特点参考strtod。

    •strtoul函数

    函数原型:unsigned long int strtoul(const char *str, char **endptr, int base);
    函数描述:把参数 str 所指向的字符串根据给定的 base 转换为一个无符号长整数,base 必须介于 2 和 36(包含)之间,或者是特殊值 0。
    函数返回:返回转换后的长整数,如果没有执行有效的转换,则返回一个零值。
    特点:参考strtol

    •calloc函数

    函数原型:void *calloc(size_t nitems, size_t size);
    函数描述:分配所需的内存空间,并返回一个指向它的指针。nitems表示要被分配的元素个数。size表示每个元素的大小。
    函数返回:返回一个指针,指向已分配的内存。如果请求失败,则返回 NULL。
    特点:
    1:malloc 和 calloc 之间的不同点是,malloc 不会设置内存为零,而 calloc 会设置分配的内存为零。

    •free函数

    函数原型:void free(void *ptr);
    函数描述:释放之前调用 calloc、malloc 或 realloc 所分配的内存空间。
    函数返回:不返回任何值。
    特点:
    1:如果传递的参数是一个空指针,则不会执行任何动作。
    2:如果指针指向的内存不是由calloc、malloc 或 realloc 所分配,则函数会发生未定义的结果。
    3:函数不会改变指针的值(指向),只是现在指向的内存区域无效。(Notice that this function does not change the value of ptr itself, hence it still points to the same (now invalid) location.)

    •malloc函数

    函数原型:void *malloc(size_t size);
    函数描述:分配所需的内存空间,并返回一个指向它的指针。size表示要申请的字节数。
    函数返回:返回一个指针 ,指向已分配大小的内存。如果请求失败,则返回NULL。

    •realloc函数

    函数原型:void *realloc(void *ptr, size_t size) ;
    函数描述:尝试重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小。
    函数返回:返回一个指针 ,指向已分配大小的内存。如果请求失败,则返回NULL。
    特点:
    1:ptr指针指向一个要重新分配内存的内存块,该内存块之前是通过调用 malloc、calloc 或 realloc 进行分配内存的。如果为空指针,则会分配一个新的内存块,且函数返回一个指向它的指针(类似malloc)。
    2:新的内存块的大小,以字节为单位。如果大小为 0,且 ptr 指向一个已存在的内存块,则 ptr 所指向的内存块会被释放,并返回一个空指针。
    3:如果请求失败,则返回NULL,此时不影响ptr所指向的内存。

    •abort函数

    函数原型:void abort(void);
    函数描述:异常中止程序执行,直接从调用的地方跳出。
    函数返回:无返回。
    特点:
    1:abort函数导致所有的流被关闭和冲洗。
    2:abort函数用以解除进程对SIGABRT信号的阻止。

    •atexit函数

    函数原型:int atexit(void (*func)(void)) ;
    函数描述:当程序正常终止时,调用指定的函数func。
    函数返回:如果函数成功注册,则该函数返回零,否则返回一个非零值。
    特点:
    1:可以在任何地方注册你的终止函数,但它会在程序终止的时候被调用。
    2:若一个程序中出现多次atexit函数,则其按照栈的方式执行(最后一个先执行,以此类推)。

    •exit函数

    函数原型:void exit(int status);
    函数描述:(正常)立即终止调用进程。status – 返回给父进程的状态值。
    对于status,如果其为0或者EXIT_SUCCESS,表示成功;如果其为EXIT_FAILURE,表示失败。
    函数返回:无返回。
    特点:
    1:任何属于该进程的打开的文件描述符都会被关闭,该进程的子进程由进程 1 继承,初始化,且会向父进程发送一个 SIGCHLD 信号。

    •getenv函数

    函数原型:char *getenv(const char *name);
    函数描述:搜索name所指向的环境字符串,并返回相关的值给字符串。
    函数返回:返回一个以 null 结尾的字符串,该字符串为被请求环境变量的值。如果该环境变量不存在,则返回 NULL。

    •system函数

    函数原型:int system(const char *command);
    函数描述:把 command 指定的命令名称或程序名称传给要被命令处理器执行的主机环境,并在命令完成后返回。
    函数返回:如果发生错误,则返回值为-1,否则返回命令的状态。
    特点:
    1:如果command为null,则只是为了测试指令系统是否有效,若有效,返回非0,否则返回0。

    •bsearch函数

    函数原型: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 所对应的比较函数升序排序。
    函数返回:如果查找成功,该函数返回一个指向数组中匹配元素的指针,否则返回空指针。
    特点:
    1:对于compar函数,若返回值小于0,表示要查找的值小于当前值;若返回值等于0,表示要查找的值等于当前值;若返回值大于0,表示要查找的值大于当前值。
    2:若数组中有多个满足条件的值,则函数可能返回任意一个,不一定是第一个。
    3:复杂度log2(num)+2。

    •qsort函数

    函数原型:void qsort(void base, size_t nitems, size_t size, int (*compar)(const void , const void*));
    函数描述:对数组进行排序。base指向要排序的数组的第一个元素的指针。nitems 由 base 指向的数组中元素的个数。size数组中每个元素的大小,以字节为单位。compar 用来比较两个元素的函数。
    返回值:无返回值。
    特点:
    1:不稳定排序(其实是基于快速排序的操作)。
    2:复杂度num*log2(num)。

    •abs函数与labs函数

    函数原型:int abs(int x);long int abs(long int x);
    函数描述:取x得绝对值。
    函数返回:返回x的绝对值。
    特点:
    1:对于浮点型及负数的取绝对值,分别定义在头文件cmath.h及头问价complex.h中。

    •div函数与ldiv函数

    函数原型:div_t div(int numer, int denom); div_t div(long int numer, long int denom);
    函数描述:把 numer(分子)除以 denom(分母)。
    函数返回:返回定义在

    rand函数

    函数原型:int rand(void) ;
    函数描述:伪随机数生成函数。
    函数返回:返回一个范围在 0 到 RAND_MAX 之间的伪随机数。
    特点:
    1:RAND_MAX 是一个常量,它的默认值在不同的实现中会有所不同,但是值至少是 32767。
    2:若随机数生成种子相同,则每次调用rand()生成的伪随机数是相同的。
    3:若使用rand函数前没有调用srand函数,系统会自动调用srand函数。

    •srand函数

    函数原型:void srand(unsigned int seed);
    函数描述:播种由函数rand使用的随机数发生器。seed是一个整型值,用于伪随机数生成算法播种。
    函数返回:无返回。
    特点:
    1:不同的seed会使得此后调用rand函数生成不同的伪随机数。
    2:如果seed设置为1,rand函数将生成和之前一样的伪随机序列。
    3:为了保持seed的独特性,通常的做法是使用time函数返回作为seed值。如srand(time(&t));

    此外,stdlib头文件还有一些处理多字节的函数,在使用过程中可自行查阅。

    参考:

    1. http://www.runoob.com/cprogramming/c-standard-library-stdlib-h.html
    2. http://www.cplusplus.com/reference/cstdlib/
    展开全文
  • 不错的stdlibstdlibstdlibstdlibstdlibstdlibstdlibstdlibstdlib
  • C语言标准库stdlib.h

    万次阅读 多人点赞 2020-02-10 18:37:56
    本文将介绍 C语言标准库&lt;stdlib.h&gt; 的 宏、函数、数据类型 在最后给出一个实例程序,尽可能运用到所有函数 宏 EXIT_SUCCESS 和 EXIT_FAILURE exit函数成功退出和失败的返回值 #define EXIT_SUCCESS ...
  • stdlib.h> #include<string.h> //void *malloc(size_t size) //分配所需的内存空间,并返回一个指向它的指针。若失败,则返回NULL //char* strcpy(char* dest, const char* src) //把 src 所指向的字符...
  • #include <stdio.h>...stdlib.h> #include <string.h> int funcmp(const void *pa, const void *pb) { return strcmp(*(char**)pa, *(char**)pb) > 0 ? 1 : -1; } int main(int ar...
  • &amp;amp;amp;lt;stdlib.h&amp;amp;amp;gt;...随机函数int rand...定义的一个数值,至少为32767 随机种子设置函数void strand(unsigned int seed) 注:seed为unsigned int类型的随机值,seed被称为随机数
  • 我在stdlib.h只找到了原型 请问他的实际实现代码在哪?
  • C语言stdlib库(#include<stdlib.h>)

    千次阅读 2017-09-05 09:44:48
    stdlib.h头文件定义了四个变量类型,用于执行一般函数的几个宏和各类函数。 库变量 以下是在头文件stdlib.h定义的变量类型: S.N. 变量和说明 1 size_t  这是一个无符号整数类型的sizeof关键字的...
  • C语言中头文件中#include "stdlib.h"的作用 stdlib 头文件即standard library标准库头文件 stdlib 头文件里包含了C、C++语言的最常用的系统函数 该文件包含了的C语言标准库函数的定义  stdlib.h里面定义了五种类型...
  • 前言:因为刷题的时候经常遇到字符串转化为数字的问题,而c语言标准库stdlib库函数可以有效地解决这个问题。所以今天做个小结。因为c++是向下兼容c语言的,支持所有的c头文件,但是为了符合c++标准,所以c头文件...
  • C语言中的#include <stdlib.h>文件的作用

    千次阅读 多人点赞 2017-03-27 14:37:35
    1、简单了解#include < stdlib.h > stdlib.h,包含了C语言的一些常用库函数。 如动态内存相关的malloc, realloc,zalloc,calloc,free等。 随机数相关的rand,srand等。 系统相关的system, getenv,setenv等。 ...
  • C语言中你可能不熟悉的头文件<cstdlib>(stdlib.h) C Standard General Utilities Library (header) C标准通用工具库(头文件) 此头文件定义了一些通用功能函数,包括动态存储器管理,随机数生成,与操作系统...
  • C语言 通用工具库 stdlib.h

    千次阅读 2018-07-01 12:43:35
    ANSI C在stdlib.h头文件定义了一些实用函数。stdlib.h声明的类型size_tsizeof运算符返回的整数类型wchar_t用于表示宽字符的整数类型div_tdiv()返回的结构类型,该类型的quot和rem成员都是int类型ldiv_tldiv()...
  • C语言学习:简单了解下stdlib中的字符串转换函数简介: 在学习C语言的时候,关于标准头文件stdlib中的一些函数也有所了解,在学习字符和字符串的时候,关于字符串的处理函数也有很多,在整形字符和整形可以看似...
  • C语言中的rand()函数

    万次阅读 多人点赞 2018-04-29 10:14:58
    rand函数,C语言中用来产生一个随机数的函数。rand函数界限:stdlib.h头文件中有宏#define RAND_MAX 0x7fff rand产生一个0-0x7fff的随机数,即最大是32767的一个数rand函数原型#include &lt;stdlib.h&gt;...
  • c语言中的随机数

    2020-06-14 21:43:52
    c语言中产生随机数 #include <stdio.h> #include <stdlib.h>//这里要注意,必须写,不然vs报错,因为rand函数在stdlib下面 #include <time.h>//这里要注意,因为随机数是根据系统日期所产生
  • C语言中qsort函数用法

    2020-12-06 01:41:56
    C语言中qsort函数用法 1.描述 本文实例汇总介绍了C语言中qsort函数用法,包括针对各种数据类型参数的排序,非常具有实用价值非常具有实用价值。 分享给大家供大家参考。C语言中的qsort函数包含在<stdlib.h>的...
  • C语言中的进制转换 itoa & sprintf

    千次阅读 2016-07-09 17:25:39
    C语言中经常会遇到将二进制、八进制、十进制、十六进制等之间的相互转换,比如:在将八进制以二进制的形式打印出来等。可以用C语言(stdlib.h)中的itoa函数来做这件事情。 char *itoa( int value, char *string,...
  • c语言中赋值截断

    2020-01-14 15:26:42
    c语言中进行变量赋值的时候,如果将字节多的数据类型赋给一个占字节少的变量类型,会发生“截断”。 发生这种情况的原因是:在赋值过程中只将占字节较长的变量的地位赋给占字节较少的变量。 如: int i=345; ...
  • C语言中的 类型转换

    2020-09-25 16:27:29
    C语言中的 类型转换 C语言中的类型转换分为隐式类型转换和强制类型转换。 隐式类型转换一般要由低字节转到高字节,否则可能会发生精度降低的情况。 #include <stdio.h> #include <string.h> #include &...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,600
精华内容 1,840
关键字:

c语言中stdlib

c语言 订阅