翻页大图网站免费友链平台

一.访问C库

如何访问C库取决于实现,下面是一些可能的方法

1.自动访问:

2.文件包含:

3.库包含:

二.数学库

以下涉及的角度均为弧度制

1.math.h库
(1)幂函数:

求float x的平方根:float sqrtf(float x);
求double x的平方根:double sqrt(double x);
求long double x的平方根:long double sqrtl(long double x);
求float x的立方根:float cbrtf(float x);
求double x的立方根:double cbrt(double x);
求long double x的立方根:long double cbrtl(long double x);
求float x的float y次幂:float powf(float x,float y);
求double x的double y次幂:double pow(double x,double y);
求long double x的long double y次幂:long double powl(long double x,long double y);//实例:
printf("%lf\n",sqrt(4));//结果:2.000000
printf("%f\n",cbrt(27));//结果:3.000000
printf("%f\n",pow(2,3));//结果:8.000000

(2)绝对值:

求int x的绝对值:int abs(int x);
求long x的绝对值:long llabs(long x);
求long long x的绝对值:long long llabs(long long x);
求float x的绝对值:float fabsf(float x);
求double x的绝对值:double fabs(double x);
求long double x的绝对值:long double fabsl(long double x);//实例:
printf("%d\n",abs(22));//结果:22
printf("%d\n",abs(-5.43));//结果:5
printf("%lf\n",fabs(-5.43));//结果:5.430000

(3)三角函数:

求float x的反余弦值:float acosf(float x);
求double x的反余弦值:double acos(double x);
求long double x的反余弦值:long double acosl(long double x);
求float x的正弦弦值:float asinf(float x);
求double x的正弦弦值:double asin(double x);
求long double x的正弦弦值:long double asinl(long double x);
求float x的反正切值:float atanf(float x);
求double x的反正切值:double atan(double x);//无法区分π/4和5π/4
求long double x的反正切值:long double atanl(long double x);
求float y/float x的反正切值:float atan2f(float y,float x);
求double y/double x的反正切值:double atan2(double y,double x);//可以区分π/4(=atan2(1,1))和5π/4(=atan2(-1.-1))
求long double y/long double x的反正切值:long double atan2l(long double y,long double x);
求float x的余弦值:float cosf(float x);
求double x的余弦值:double cos(double x);
求long double x的余弦值:long double cosl(long double x);
求float x的正弦值:float sinf(float x);
求double x的正弦值:double sin(double x);
求long double x的正弦值:long double sinl(long double x);
求float x的正切值:float tanf(float x);
求double x的正切值:double tan(double x);
求long double x的正切值:long double tanl(long double x);//实例:
printf("%f\n",acos(0));//结果:1.570796
printf("%f\n",asin(1));//结果:1.570796
printf("%f\n",atan(1));//结果:0.785398
printf("%f\n",atan2(1,1));//结果:0.785398
printf("%f\n",atan(-1));//结果:-0.785398
printf("%f\n",atan2(1,-1));//结果:2.356194
printf("%f\n",atan2(-1,1));//结果:-0.785398
printf("%f\n",cos(3.14));//结果:-0.999999
printf("%f\n",sin(1.57));//结果:1.000000
printf("%f\n",tan(0.785));//结果:0.999204

(4)指/对数函数:

求float x的以e为底的指数:float expf(float x);
求double x的以e为底的指数:double exp(double x);
求long double x的以e为底的指数:long double expl(long double x);
求float x的自然对数:float logf(float x);
求double x的自然对数:double log(double x);
求long double x的自然对数:long double logl(long double x);
求float x的以10为底的对数:float log10f(float x);
求double x的以10为底的对数:double log10(double x);
求long double x的以10为底的对数:long double log10l(long double x);//实例:
printf("%f\n",exp(1));//结果:2.718282
printf("%f\n",log(exp(1)));//结果:1.000000
printf("%f\n",log10(10));//结果:1.000000

(5)取整:

求不小于float x的最小整数:float ceilf(float x);
求不小于double x的最小整数:double ceil(double x);
求不小于long double x的最小整数:long double ceill(long double x);
求不大于float x的最大整数:float floorf(float x);
求不大于double x的最大整数:double floor(double x);
求不大于long double x的最大整数:long double floorl(long double x);//实例:
printf("%f\n",ceil(3.14));//结果:4.000000
printf("%f\n",ceil(3.98));//结果:4.000000
printf("%f\n",ceil(3));//结果:3.000000
printf("%f\n",floor(3.14));//结果:3.000000
printf("%f\n",floor(3.98));//结果:3.000000
printf("%f\n",floor(3));//结果:3.000000

(6)通过泛型选择表达式选择合适的函数版本:

#include <stdio.h>
#include <math.h>
#define RTD (180/4*atanl(1))
#define SQRT(X) _Generic((X),float:sqrtf,long double:sqrtl,default:sqrt)(X)
#define SIN(X) _Generic((X),float:sinf((X)/RTD),long double:sinl((X)/RTD),default:sin((X)/RTD))int main(void) {float x=45.0f;double xx=45.0;float s=SQRT(x);double ss=SQRT(xx);printf("%.17f\n",s);//结果:6.70820379257202150printf("%.17Lf\n",ss);//结果:6.70820393249936940float x2=45.0f;double xx2=45.0;float s2=SIN(x2);double ss2=SIN(xx2);printf("%.17f\n",s2);//结果:0.95605564117431641printf("%.17Lf\n",ss2);//结果:0.95605565732762954return 0;
}

2.tgmath.h库:

tgmath.h中定义了泛型类型宏,与math.h中各double版函数同名,但会依据提供的参数类型展开为float/double/long double版函数:
#include <stdio.h>
#include <tgmath.h> int main(void) {float x=3.1415;//调用sqrt()宏,展开为sqrtf()函数printf("%d,%f\n",sizeof(sqrt(x)),sqrt(x));//结果:4,1.772428//如果要调用sqrt()函数而非sqrt()宏:printf("%d,%f",sizeof((sqrt)(x)),(sqrt)(x));//结果:8,1.772428//也可以通过下式调用sqrt()函数://return 0;printf("%d,%f",sizeof((*sqrt)(x)),(*sqrt)(x));
}
另外,如果编译器支持复数运算,这些宏就也能展开为float complex/double complex/long double complex版函数

3.complex.h库
(1)运算函数:

math.h相应的复数运算库.函数名和math.h大体相同,只是开头多1个c,且返回float complex/double complex/long double complex//实例:见 (2) 部分

(2)取值函数:

返回float complex x的实部:float crealf(float complex x);
返回double complex x的实部:double creal(double complex x);
返回long double complex x的实部:long double creall(long double complex x);
返回float complex x的虚部:float cimagf(float complex x);
返回double complex x的虚部:double cimag(double complex x);
返回long double complex x的虚部:long double cimagl(long double complex x);//实例:
#include <stdio.h>
#include <complex.h> int main(void) {float complex c=1+2i;float complex rc=csqrtf(c); printf("%d,%f,%f",sizeof(rc),crealf(rc),cimagf(rc));//结果:8,1.272020,0.786151return 0;
}

三.字符,字符串与文件库
1.stdio.h库
(1)字符(串)输出函数:

进行格式化的输出:int <n>=printf();//参见 C语言基础.常用命令,运算符,控制符.1//参数说明:n:返回被输出的字符数输出字符串到stdout:puts();//参见 C语言细节.字符串.三.1#########################################################################################输出单个字符到stdout:putchar(<c>);//参见 C语言基础.常用命令,运算符,控制符.1.(2) 部分

(2)字符(串)输入函数:

要求进行格式化的输入:int <n>=scanf();//参见 C语言基础.常用命令,运算符,控制符.3//参数说明:n:返回成功读取的数据项数从stdin读取整行输入:gets();//参见 C语言细节.字符串.二.2.(1)从stdin读取有长度上限的整行:gets_s();//参见 C语言细节.字符串.二.2.(3)#########################################################################################从stdin读取单个字符:<c>=getchar();//参见 C语言基础.常用命令,运算符,控制符.3.(2) 部分

(3)标准IO函数:

打开指定文件:<fp>=fopen("<fname>","<mode>");
关闭指定文件:fclose(<fp>);
从文件中读取字符:<ch>=getc(<fp>);
写入指定字符的文件中:putc(<ch>,<fp>);//详情参见 C语言细节.字符输入/输出.3.(4) 与 C语言细节.文件的输入与输出.二 部分 

(4)sprintf():

将数据写入字符串:sprintf(<tstr>,"<content>"[,<param1>...]);//参数说明:<content>/<param>同printf()tstr:将数据写入到该字符串//应是1个有足够空间的数据对象(如数组),而不能是指针//实例:
#include <stdio.h>int main(void) {char b[10];sprintf(b,"z%d",11);printf("%s\n",b);//结果:z11sprintf(b+3,"kkk");printf("%s",b);//结果:z11kkkreturn 0;
}

(5)文件IO函数:

输出格式化内容到文件:fprintf(<fp>,"<content>"[,<param1>...]);
从文件读取格式化内容:fscanf(<fp>,"<format>",<varp>);
读取有长度上限的整行内容:[<p>=]fgets(<var>,<len>,<pos>);//参见 C语言细节.字符串.二.2.(2)
输出字符串到指定位置:fputs("<str>",<pos>);//参见 C语言细节.字符串.三.2

(6)随机访问函数:

将文件中的光标移动到指定位置:int <r>=fseek(<fp>,<offset>,<mode>);
查找光标当前在文件中的位置:long <fpos>=ftell(<fp>);//参见 C语言细节.文件的输入与输出.四.1 部分

(6)文件重定向:

进行文件重定向:FILE * <rp>=freopen(const char * filename,const char * mode,FILE * stream)//参见 C语言细节.文件的输入与输出.五 部分

2.string,h库

注意:如果使用ANSI C之前的编译器,不应加下述命令:
#include <string.h>

(1)strlen():

返回字符串的字符长度:int <len>=strlen(<str>);//即返回字符串中有几个字符(空字符'\0'不计入,因此strlen(<str>)+1才是<str>实际包含的字符数)//参数说明:str:字符数组或字符串常量len:返回字符串的字符长度//实例1:
#include <stdio.h>
#include <string.h> 
#define aaa "asdfgx"int main(void) {char name[5];scanf("%s",name);//输入:tywprintf("%d,%d\n",strlen(name),strlen(aaa));//结果:3,6return 0;
}//实例2:
#include <stdio.h>
#include <string.h> void change(char * string,unsigned int size) {if (strlen(string)>size) {string[size]='\0';}
}int main(void) {char msg[]="Things should be as simple as possible,but not simpler.";puts(msg);change(msg,38);puts(msg);puts(msg+39);return 0;
}
//结果:
Things should be as simple as possible,but not simpler.
Things should be as simple as possible
but not simpler.

(2)字符串的拼接:

拼接字符串:[char * <str1p>=]strcat(<str1>,<str2>);//拼接后的字符串为"<str1><str2>",并且<str1>会被修改为拼接后的字符串//相当于把<str2>中的字符按顺序放到剩余的分配给<str1>的内存空间中//注意:拼接后<str1>只在结尾有1个'\0',原本<str1>中的'\0'会被删掉//因此strlen(<str1(拼接后)>)=strlen(<str1(拼接前)>)+strlen(<str2>)+1//参数说明:str1,str2:要拼接的字符串//因为<str1>会被修改为拼接后的字符串,因此不应给<str1>传入字符串字面量,否则得不到拼接后的字符串//而<str2>不变,因此可以传入字符串字面量str1p:返回str1的地址//实例:
#include <stdio.h>
#include <string.h> int main(void) {char msg[30];char begin[]="I want to say that ";gets(msg);puts(msg);strcat(begin,msg);puts(begin);puts(msg);printf("end")；return 0;
}
//结果:
blablabla
blablabla
I want to say that blablabla
blablabla
end//#######################################################################################//strcat()的问题:
strcat()无法检查分配给<str1>的内存空间是否足以容纳拼接后的字符串,如果空间不够大,多出来的字符就会溢出
到相邻的存储单元,从而引发种种问题,如:
#include <stdio.h>
#include <string.h> int main(void) {char msg[30];char begin[]="I want to say that ";gets(msg);puts(msg);strcat(begin,msg);puts(begin);puts(msg);printf("end")；return 0;
}
//结果:
I am your father.
I am your father.
I want to say that I am your father.
her.
end要解决这个问题,可以使用strlen()检测字符串长度,也可以使用strncat()//#######################################################################################进行有上限的字符串拼接:[char * <str1p>=]strncat(<str1>,<str2>,<n>);//相当于把<str2>中的字符按顺序放到剩余的分配给<str1>的内存空间中//放完<str2>的所有字符(碰到'\0')或添加的字符数达到上限时就停止//参数说明:<str1>/<str2>/<str1p>同strcat()n:指定最大添加的字符数//实例:
#include <stdio.h>
#include <string.h> int main(void) {char msg[25];char begin[]="I want to say that ";gets(msg);puts(msg);strncat(begin,msg,5);puts(begin);puts(msg);printf("end"); return 0;
}
//结果:
I am your father.
I am your father.
I want to say that I am
I am your father.
end

(3)字符串的比较:

比较2个字符串的内容是否相同:int <r>=strcmp(<str1>,<str2>);//如果直接使用运算符=或!=进行比较,则比较的是字符串的地址而非内容//该函数通过关系运算符来比较字符串//因为数组表示法/指针表示法/字符串字面量都被视为指针//参数说明:str1,str2:要进行比较的2个字符串//注意:不能是字符(如"A"合法,'A'不合法)r:如果2个字符串相同,返回0;否则返回非0值//实例:
#include <stdio.h>
#include <string.h> int main(void) {char in[25];char pre[]="hahaha";gets(in);while(strcmp(in,pre)) {printf("wrong answer,please input again\n");gets(in);}puts(in);printf("end");return 0;
}
//结果:
ahahah
wrong answer,please input again
hahaha
hahaha
end注意:strcmp()比较的是字符串而不是这个字符数组
char a[5]="aaa";
char b[10]="aaa";
printf("%d",strcmp(a,b));//结果:0
//虽然数组a,b占用的空间大小不同,但存储的字符串的内容相同,因此strcmp()返回0//#######################################################################################比较字符串的前指定个字符:strncmp(<str1>,<str2>,<n>);//比较规则同strcmp()//参数说明:<str1>,<str2>同strcmp()n:指定只比较前n个字符//实例:
printf("%d\n",strncmp("apples","apple",5));//结果:0
printf("%d\n",strncmp("app","apple",3));//结果:0
printf("%d\n",strncmp("aaacd","aabcd",5));//结果:-1

• 返回值问题:

//规则:
①如果2个字符串完全相同,返回0;如果<str1>的首字符在按ASCII码表中靠前,返回负值;否则返回正值严格来说,是按"机器排列顺序"进行比较,不过通常都是ASCII码
②如果2个字符串的首字符相同,则依次比较之后的字符(仍按照①的规则),直到第1个不同的字符
③在某些系统中,返回的正/负值只会是±1,另一些系统中则是ASCII码的差值不过通常情况下,返回的具体值并不重要,需要关注的只是其为正/负/0printf("%d\n",strcmp("AAA","AAA"));//结果:0
printf("%d\n",strcmp("AAA","BBB"));//结果:-1
printf("%d\n",strcmp("BBB","AAA"));//结果:1
printf("%d\n",strcmp("A","B"));//结果:-1
printf("%d\n",strcmp("B","A"));//结果:1
printf("%d\n",strcmp("C","A"));//结果:1//某些系统中会返回2,即二者的ASCII码之差
printf("%d\n",strcmp("Z","a"));//结果:-1
printf("%d\n",strcmp("apples","apple"));//结果:1//在该比较中,前面的字符均相同,最后的比较是'\0'和's',因为'\0'的ASCII码为0,因此返回正值
printf("%d\n",strcmp("a","/"));//结果:1

• 字符的比较问题:

可以使用关系运算符来比较字符,如:
char ch=getchar();
if (ch=='q') {printf("OK\n");
}
但不要把字符作为strcmp()的参数传入

(4)字符串的拷贝:

拷贝整个字符串:[char * <rp>=]strcpy(<tstr>,<fstr>);//不仅会拷贝变量本身,也会拷贝字面量:即(&<fstr>!=&<tstr>)&&(<fstr>!=<tstr>)//注意:<fstr>是该变量指向的字符串字面量的内存地址,&<fstr>则是该变量的地址//参数说明:参数顺序可以类别赋值表达式tstr:将<fstr>拷贝到<tstr>("目标字符串")//应是1个有足够空间的数据对象(如数组)//不能是指针,因为说明数组将分配储存数据的空间,而声明指针只分配储存1个地址的空间fstr:要拷贝的字符串("源字符串")//可以是指针/数组/字符串字面量rp:返回<tstr>的地址//实例:
#include <stdio.h>
#include <string.h> int main(void) {char * a="aaaa";char b[4];int r=strcpy(b,a);printf("%s,%s,%d,%d,%d,%d\n",a,b,a,b,&a,&b);//结果:aaaa,aaaa,4210688,6487568,6487576,6487568printf("%d",r);//结果:6487568return 0;
}//注意:<tstr>不一定指向某个数组的开始位置,也可以指向某数组中间的某位置
#include <stdio.h>
#include <string.h> int main(void) {char * a="aaaa";char b[10]="bbb";int r=strcpy(b+3,a);printf("%s,%s,%d,%d,%d,%d\n",a,b,a,b,&a,&b);//结果:aaaa,bbbaaaa,4210688,6487552,6487568,6487552//这里因为用的是b+3,所以把"bbb"后面的'\0'覆盖掉了printf("%d\n",r);//结果:6487555strcpy(b+8,"d");printf("%s",b);//结果:bbbaaaa//因为在输出'd'之前就遇到了'\0'return 0;
}//#######################################################################################有上限的字符串拷贝:[char * <rp>=]strncpy(<tstr>,<fstr>,<n>);//除了存在拷贝字符数的上限外,均与strcpy()相同//注意:由于不一定完全拷贝<fstr>,拷贝后的<tstr>结尾不一定有'\0',可能需要自行设置//参数说明:<tstr>/<fstr>/<rp>同strcpy()n:指定拷贝的最大字符数//实例:
#include <stdio.h>
#include <string.h> int main(void) {char * a="aaaa";char b[10]="bbb";int r=strncpy(b+3,a,2);printf("%s,%d,%d",b,b,r);//结果:bbbaa,6487552,6487555return 0;
}

(5)字符的查找:

查找首个指定字符:char * <fep>=strchr(<s>,<c>);//参数说明:s:指定在哪个字符串中进行查找c:指定要查找的字符//可以传入字符,也可以传入整数fep:返回1个指向<c>首次出现的位置的指针(如果在<s>中没有找到<c>,则返回1个空指针)//注意:结尾处的'\0'也在查找范围内//实例1:
#include <stdio.h>int main(void) {char a[10]="mmadsaj";char * p=strchr(a,'a');printf("%d,%d",a,p);//结果:6487552,6487554return 0;
}//实例2:
#include <stdio.h>int main(void) {char a[10]="mmadsaj";char * p=strchr(a,'z');printf("%d,%d",a,p);return 0;
}//#######################################################################################查找首个指定的多个字符:char * <fp>=strpbrk(<fstr>,<astr>);//参数说明:fstr:指定在该字符串中进行查找astr:所有要查找的字符构成的字符串fp:如果<astr>中的任一字符在<fstr>中,返回指向<fstr>中第1个包含在<astr>中的字符的指针;否则返回空指针//实例1:
#include <stdio.h>int main(void) {char a[10]="mmadsaj";char * p=strpbrk(a,"fda");printf("%d,%s",a,p);//结果:6487552,adsajreturn 0;
}//实例2:
#include <stdio.h>int main(void) {char a[10]="mmadsaj";char * p=strpbrk(a,"zxy");printf("%d,%d",a,p);//实例:6487552,0return 0;
}//#######################################################################################查找尾个指定字符:char * <lep>=strrchr(<s>,<c>);//参数说明:<s>/<c>同strchr()lep:返回1个指向<c>最后1次出现的位置的指针(如果在<s>中没有找到<c>,则返回1个空指针)//注意:结尾处的'\0'也在查找范围内//#######################################################################################查找首个指定子字符串:char * <ep>=strstr(<fstr>,<astr>);//参数说明:fstr:指定在该字符串中查找astr:指定要查找的子字符串ep:返回指向<fstr>中<astr>首次出现的位置的指针(如果<astr>不出现在<fstr>中,返回空指针)//实例:
#include <stdio.h>int main(void) {char a[10]="mmadsaj";char * p=strstr(a,"ads");printf("%d,%d\n",a,p);//结果:6487552,6487554p=strstr(a,"asa");printf("%d,%d",a,p);//结果:6487552,0return 0;
}//#######################################################################################查找尾个指定子字符串:char * <ep>=strrstr(<fstr>,<astr>);//参数说明:其他同上ep:返回指向<fstr>中<astr>最后1次出现的位置的指针(如果<astr>不出现在<fstr>中,返回空指针)

(6)拷贝(任意类型的)数组:

拷贝数组:void * memcpy(void * restrict s1,const void * restrict s2,size_t n);
拷贝数组:void * memmove(vois * s1,const void * s2,size_t n);//区别在于memcpy()使用restrict关键字,即假设2个内容区域没有重叠,从而允许编译器进行优化//如果使用memcpy()时2个内容区域有重叠,该行为是未定义的//注意:这2个函数不知道数据的类型,而只负责拷贝字节,并且拷贝时不会进行数据类型转换//参数说明:s1,s2:从s2指向的位置拷贝到s1指向的位置n:指定待拷贝的内容占用的字节数//实例:
#include <stdio.h>
#include <string.h>int main(void) {int a[5]={1,2,3,4,5};int b[4];memmove(b,a,4*sizeof(int));int i;for (i=0;i<4;i++) {printf("%d ",b[i]);}return 0;
}
//结果:
1 2 3 4

(7)重置数组:

将str中的前n个字符设为c:void * memset(void * str,int c,size_t n);//参数说明:str:指定字符串c:指定要设为的字符n:指定设置前几个字符//实例:
#include <stdio.h>
#include <string.h> int main(void) {char s[]="I am your father";printf("%s\n",s);memset(s,114,4);printf("%s\n",s);memset(s+4,'e',2);printf("%s",s);return 0;
}
//结果:
I am your father
rrrr your father
rrrreeour father

3.ctype.h库

ctype.h中的函数通常作为"宏"(Macro)来实现

(1)字符测试函数:

如果为指定类型,返回[真];否则返回[假]
下述函数中的参数c都是字符或字符变量,不能是字符串是否是字母或数字:isalnum(<c>);
是否是字母:isalpha(<c>);
是否是标准的空白字符或本地化指定为空白的字符:isblank(<c>);标准的空白字符包括空格,水平制表符,换行符
是否是控制字符(如Ctrl+B):iscntrl(<c>);
是否是数字:isdigit(<c>);
是否是除空格外的任意可打印字符:isgraph(<c>);
是否是小写字母:islower(<c>);
是否是可打印字符:isprint(<c>);
是否是标点符号:ispunct(<c>);包括除空格/字母/数字外的任何可打印字符)
是否是空白字符:isspace(<c>);除isblank()包括的字符外,还包括换页符,回车符,垂直制表符
是否是大写字母:isupper(<c>);
是否是16进制数字符:isxdigit(<c>);

(2)字符映射函数:

将大写字母转换成小写字母:<c1>=tolower(<c2>);
将小写字母转换成大写字母:<c1>=toupper(<c2>);//注意:不是直接在原变量上进行转换,需要赋值给新变量//参数说明:c2:要转换的字符c1:转换后的字符//实例:
char a='d';
a=toupper(a);
printf("%c\n",a);//结果:D
a=tolower(a);
printf("%c\n",a);//结果:d

四.通用工具库
1.stdlib.h库
(1)将字符串转换为数字:

将str转换为整数:int <i>=atoi("<istr>");//参数说明:istr:指定要进行转换的字符串//注意:该字符串的内容必须以整数开始//实际上是指向要转换的字符串的指针i:返回转换后得到的整数值//实例:
#include <stdio.h>int main(void) {int a=atoi("123");int b=atoi("a");int c=atoi("123.93");int d=atoi("-3");int d=atoi("-31efd");printf("%d\n",a);//结果:123printf("%d\n",b);//结果:0//转换失败//注:在C标准中,这种情况是未定义的printf("%f\n",c);//结果:123.000000//截断到了整数位printf("%d\n",d);//结果:-3printf("%d\n",e);//结果:-31//只转换开头处的整数return 0;
}//#######################################################################################将str转换为double:double <d>=atof("<dstr>");//参数说明:类似于atoi()//#######################################################################################将str转换为long:long <l>=atol("<lstr>");//参数说明:类似于atoi()//#######################################################################################检查并将str转换为long:long <l>=strtol("<lstr>",<eptr>,<base>);//会先检查字符串是否以数字开始//可以指定输入的数字字符串采用的进制(输出统一采用10进制)//参数说明:<lstr>类似于atoi()eptr:指向结束字符的指针的地址//如输入10进制数字"31at",结束在'a'处,则<eptr>是指向'a'的指针的地址//函数执行完成后,该地址会被储存在<eptr>中base:指定输入的数字字符串采用的进制//最高到36进制(此时'a'~'z'均作为数字)//实例:
#include <stdio.h>
#define LIM 30int main(void) {char n[LIM];char * end;long v;while (gets(n),n[0]!='q') {v=strtol(n,&end,10);printf("base 10 input:%ld,end at %s\n",v,end);v=strtol(n,&end,16);printf("base 16 input:%ld,end at %s\n",v,end);v=strtol(n,&end,36);printf("base 36 input:%ld,end at %s\n",v,end);}return 0;
}
//结果:
10
base 10 input:10,end at
base 16 input:16,end at
base 36 input:36,end at
10atom
base 10 input:10,end at atom
base 16 input:266,end at tom
base 36 input:60971206,end at
z
base 10 input:0,end at z
base 16 input:0,end at z
base 36 input:35,end at
q//#######################################################################################检查并将str转换为unsigned long:unsigned long <ul>=strtoul("<ulstr>",<eptr>,<base>);//会先检查字符串是否以数字开始;可以指定输入的数字字符串采用的进制(输出统一采用10进制)//参数说明:<ulstr>类似于atoi(),<eptr>/<base>类似于<strtol>//#######################################################################################检查并将str转换为double:double <d>=strtod("<dstr>",<eptr>);//会先检查字符串是否以数字开始//参数说明:类似于atoi(),<eptr>类似于<strtol>

(2)将数字转换成字符串:

将整数转换成str:itoa();//#######################################################################################将浮点数转换成str:itoa();//#######################################################################################上述2个函数不是C标准库的成员,可以用sprintf()代替它们以提高兼容性

(3)生成随机数:

生成1个属于[0,RAND_MAX]的随机数:int rand();//实际是利用算法(如线性同余法)生成的伪随机数,在一定范围内可看成随机数//生成随机数有多种算法,ANSI C允许C实现针对特定机器使用最佳算法,但也提供了可移植的标准算法//C11规定RAND_MAX至少为32767,该宏定义在stdlib.h中//每次运行程序,如果种子不变,则第n个rand()生成的数都是相同的,这是由于随机数生成算法是不变的//实例1:
#include <stdio.h>
#include <stdlib.h>int main(void) {printf("%d",RAND_MAX);//结果:32767return 0;
}//实例2:
#include <stdio.h>
#include <stdlib.h>int main(void) {int i;for (i=0;i<10;i++) {printf("%d\n",rand());}return 0;
}
//结果:
41
18467
6334
26500
19169
15724
11478
29358
26962
24464//实例3:
#include <stdio.h>
#include <stdlib.h>int main(void) {int i;for (i=0;i<5;i++) {printf("%d\n",rand()%100);//生成1个属于[0,100)的随机数}return 0;
}
//结果:
41
67
34
0
69//#######################################################################################为rand()设置随机数种子:void srand(<seed>);//rand()以随机数种子为基准,通过递推公式推出一系列数,当这些数很多时,就符合正态公布,从而相当于产生了随机数//如果没有手动设置随机数种子,调用rand()时会自动将随机数种子设为1//参数说明:seed:提供1个种子值;为unsigned int//经常为(unsigned int)time(0)/(unsigned int)geypid(0)//实例:
#include <stdio.h>
#include <stdlib.h>int main(void) {srand(0);printf("%d",rand());//结果:38return 0;
}//#######################################################################################//1种实现:将2个文件一起编译
//函数定义.c:
static unsigned long int next=1;//种子int rand1(void) {next=next*1103515245+12345;return (unsigned int)(next/65535)%32768;
}void srand1(unsigned int seed) {next=seed;
}
//调用.c:
#include <stdio.h>extern void srand1(unsigned int seed);
extern int rand1(void);int main(void) {int count;unsigned seed;printf("Please enter your choice of seed:");while (scanf("%u",&seed)==1) {srand1(seed);for (count=0;count<5;count++) {printf("%d\n",rand1());}printf("Please enter next seed (q to quit):");}return 0;
}
//结果:
Please enter your choice of seed:2
909
22817
10240
12914
25838
Please enter next seed (q to quit):3
17747
7108
10365
8313
20623
Please enter next seed (q to quit):2
909
22817
10240
12914
25838
Please enter next seed (q to quit):q

(4)结束程序:

参见:https://blog.csdn.net/weixin_43520054/article/details/94392365
https://blog.csdn.net/wy1550365215/article/details/70216750

关闭所有打开的文件并结束当前程序:int <ecode>=exit(int status);//main()返回系统时会自动调用exit()//参数说明:status:表示程序是正常退出(为0)还是异常退出(为非零值,不同的值用于区分不同错误)//也可以分别使用EXIT_SUCCESS/EXIT_FAILURE,这样可移植性更好.这2个宏也定义在stdlib.h中//返回值也是status;在有多个进程时,如果要检测上个进程是否正常退出的,就要用到返回值//注意:不同操作系统能识别的返回值的访问不同,但C标准规定了1个最小的范围,尤其是0表示正常退出//实例:
#include <stdio.h>
#include <stdlib.h>int main(void) {printf("AAA\n");exit(EXIT_SUCCESS);printf("BBB");return 0;
}
//结果:
AAA//####################################################################################################################注册退出程序时要调用的函数:int atexit(void (*func)(void));//这些函数称为"登记函数";1个函数被注册几遍就会被执行几遍;ANSI C保证至少可以注册32个函数//调用exit()时会执行注册了的函数,执行顺序与注册顺序相反,即后注册的先执行//参数说明:func:指定要注册的函数;为函数指针(如函数名)//该函数应不带任何参数且返回void,通常用于执行一些清理任务(更新监视程序的文件,重置环境变量...)//实例:
#include <stdio.h>
#include <stdlib.h>void f(void) {printf("Exit Exit Exit\n");
}int main(void) {atexit(f);printf("AAA\n");atexit(f);printf("BBB\n");return 0;
}
//结果:
AAA
BBB
Exit Exit Exit
Exit Exit Exit//####################################################################################################################abort();

• exit()与return语句:

根据ANSI C的规定,在最初调用的main()中调用exit()与使用return语句的效果相同,如:
return 0;
相当于:
exit(0);
但如果不是在最初调用的main()中,如在1个递归调用main()的程序中或在其他函数中,return
语句只会把控制权交给上1级调用,而exit()仍会终止程序

• 退出程序的顺序:

调用exit()→由exit()执行"登记函数"→由exit()完成清理工作(刷新所有输出流,关闭所有打开的流,关闭由tmpfile()创建的临时文件)→exit()把
控制权返回主机环境并报告终止状态(如果可能的话)

(5)排序:

进行快速排序:void qsort(void * base,size_t nmemb,size_t size,int (*compar)(const void * p,const void * q));//参数说明:base:指定指向要排序的数组首元素的指针(如<avar>,&<avar>[0])//可以是任何类型的数组,因为ANSI C允许把任何类型的指针强制转换为指向void的指针nmemb:指定待排序项的数量size:指定每个元素的大小(单位为B)compar:指定1个函数指针,该函数用于确定排序的顺序//该函数的参数为2个指向待比较的项的指针//若返回1,则将p放到q前面;若返回-1,则将q放到p前面;若返回0,则p/q的顺序不确定//实例:
#include <stdio.h>
#include <stdlib.h>int f(const void * p1,const void * p2) {const double * a=(const double *)p1;const double * b=(const double *)p2;if ((*a)>(*b)) {//此时将从小到大排序return 1;} else if ((*a)<(*b)) {return -1;} else if ((*a)==(*b)) {return 0;}//if ((*a)>(*b)) {//此时将从大到小排序//	return -1;//} else if ((*a)<(*b)) {//	return 1;//} else if ((*a)==(*b)) {//	return 0;//}
}int main(void) {double arr[20]={3,6,1,14,0,32,1,45,9,22,45,6,10,94,34,2,44,19,3,65};qsort(arr,20,sizeof(double),f);int i;for (i=0;i<20;i++) {printf("%f ",arr[i]);}return 0;
}
//结果:
0.000000 1.000000 1.000000 2.000000 3.000000 3.000000 6.000000 6.000000 9.000000 10.000000 14.000000 19.000000 22.000000 32.000000 34.000000 44.000000 45.000000 45.000000 65.000000 94.000000

(6)查找:

进行二分查找:void * r=bsearch(const void * key,const void * base,size_t nitems,size_t size,int (* compar)(const void *,const void *));//参数说明:其他参数同qsort()key:指定指向要查找的值的指针nitems:指定数组元素数r:返回查找结果//如果查找成功,则返回指向数组中指定元素的指针;否则,返回空指针//实例:
#include <stdio.h>
#include <stdlib.h>int values[]={5,20,29,32,63};int cmp(const void * a, const void * b) {return *(int *)a-*(int *)b;
}int main () {int * item;int key=32;item=(int *)bsearch(&key,values,5,sizeof(int),cmp);if(item!=NULL) {printf("Found item = %d\n", *item);}else {printf("Item = %d could not be found\n", *item);}return(0);
}
//结果:
Found item = 32

2.malloc.h库

使用下述命令也可:
#include <stdlib.h>
可简单认为stdlib.h包含malloc.h
ANSI C建议使用stdlib.h,但许多C编译要求使用malloc.h

(1)malloc():

功能:请求操作系统分配内存
详情参见 动态内存分配.三.1 部分

(2)free():

功能:释放内存
详情参见 动态内存分配.三.2 部分

(3)calloc():

请求操作系统分配多个内存单元:void * calloc(size_t <num>,size_t <big>);//size_t通常是unsigned int//在ANSI C之前返回char*,ANSI C规定返回void*//参数说明:num:指定需要的存储单元的个数big:指定每个存储单元占用的字节数请求分配多个内存单元并强制转换:<type> * <var>=(<type> *)calloc();//参数说明:type:要转换成的数据类型//实例:
#include <stdio.h>
#include <stdlib.h>int main(void) {long * newmem;newmem=(long *)calloc(100,sizeof(long));printf("%d",*(newmem+2));//结果:0//所有元素都会被自动初始化为0/' 'return 0;
}

五.其他
1.断言库assert.h:

assert.h是1个用于辅助调试程序的小型库,由assert()宏构成,接受1个整型表达式作为参数.如果表达式为假,就在stderr中写入1条错误信息,并
调用stdlib.h中的abort()终止程序:
#include <stdio.h>
#include <assert.h>
#include <math.h>int main(void) {double x, y, z;printf("Enter 2 numbers (use \",\" to seperate,first one must be bigger than second one):");while (scanf("%lf,%lf", &x, &y) == 2) {printf("You enter %lf and %lf\n", x, y);fflush(stdin); z = x * x - y * y;assert(z >= 0);printf("The answer is %lf\n", sqrt(z));printf("Enter 2 numbers (use \",\" to seperate,first one must be bigger than second one):");}return 0;
}
//结果:
Enter 2 numbers (use "," to seperate,first one must be bigger than second one):4,3
You enter 4.000000 and 3.000000
The answer is 2.645751
Enter 2 numbers (use "," to seperate,first one must be bigger than second one):1,2
You enter 1.000000 and 2.000000
Assertion failed!//具体的错误信息由编译器决定(这里是TDM-GCC 4.9.2 64-bit Release)Program: E:\Program\C_C++\1.exe//程序
File: E:\Program\C_C++\1.c, Line 12//源代码文件Expression: z >= 0//为false的表达式使用if语句也可以实现类似的效果.但assert()宏有几个优点:
①可以自动识别出现问题的文件/行号/表达式
②调试完毕时,在包含assert.h前加入以下代码:
#define NDEBUG
即可禁用所有assert()宏.如果需要再次调试,只需去除上述代码以重新启用assert()宏//####################################################################################################################C11新增了_Static_assert声明._Static_assert()接受2个参数,第1个参数是1个整型常量表达式(不能包含变量),第2个参数是1个字符串.若第
1个表达式为假,程序会无法通过编译,并且编译器会显示第2个参数:
#include <stdio.h>
#include <assert.h>
#define SA 333 //_Static_assert(SA/111-3,"wrong1");int main(void) {_Static_assert(SA/111-3,"wrong2");return 0;
}
//报错:
//[Error] static assertion failed: "wrong1"
[Error] static assertion failed: "wrong2"
使用_Static_assert声明可以提高调试效率,因为无需编译完成并运行程序

2.时间库time.h
(1)time():

返回时间:time_t time(<n>);//time_t定义在//参数说明:n:

3.可变参数库stdarg.h:

该库提供1个类似于变参宏的功能,用于使函数接受数量可变的参数