你好，我是一名大一新生，在北京航空航天大学学习，我是信息大类的学生，需要学习比较难的C语言程序设计基础，现在我希望为自己整理一份C语言示例，里面包含一些复杂单有效的操作，一些函数功能的示例，一些错误的示范，如：#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <limits.h>
#define EPS 1e-9
#define MOD 100000000
#define in int
#define ll long long
#define fl float
#define db double
#define ch char
#define vd void
#define sc scanf
#define pr printf
#define sc_in(x) sc("%d", &(x))
#define sc_ll(x) sc("%lld", &(x))
#define sc_db(x) sc("%lf", &(x))
#define sc_ch(x) sc("%c", &(x))
#define sc_st(str) sc("%s", (str))
#define pr_in(x) pr("%d", x)
#define pr_ll(x) pr("%lld", x)
#define pr_db(x) pr("%lf", x)
#define pr_ch(x) pr("%c", x)
#define pr_st(x) pr("%s", x)
#define pr_inn(x) pr("%d\n", x)
#define pr_lln(x) pr("%lld\n", x)
#define pr_dbn(x) pr("%lf\n", x)
#define pr_chn(x) pr("%c\n", x)
#define pr_stn(x) pr("%s\n", x)
#define pr_n pr("\n")
#define feq(a, b) (fabs((a) - (b)) < EPS)
#define ArrayNum(x) (sizeof(x)/sizeof(x[0]))
;//位运算基础
/*
1.按位与 ：全1 则1：原位&1不变，原位&0清零
2.按位或 ：有1 则1：原位|0不变，原位|1变一
3.按位异或：相异则1：原位^0不变，原位^1翻转
4.按位取反：01 互换：
5.左移：左移n位，左侧溢出省略，右侧空位补0，左移一位相当于乘以2
6.右移：右移n位，右侧溢出省略，左空位补0/1，右移一位相当于除以2
补0 ：无符号数：逻辑位移：%u
补1 ：有符号数：算数位移：%d
e.1. 将x（单字节）的第2至5位设置为1001：
1.tmp=((1<<7)|(1<<6)|(1<<1)|(1));//以无关位为移动位数作用于1
2.x&=tmp;
3.y=(1<<5)|(1<<2); //以x中该换为1的位数作用于1
4.x|=y;
e.1+.将x（单字节）的第2至5位设置为1001：
1.tmp=(1<<5)|(1<<2); //以x中该换为1的位数作用于1
2.x|=tmp;
3.x&=~(1<<3); //将x中待清为0的位数作用于1
4.x&=~(1<<4); //将x中待清为0的位数作用于1
.x&=~((1<<3)|(1<<4));
e.2. 将无符号整数a的bit i~bit j赋值n1
将无符号整数a的bit m~bit n赋值n2
1.a&=~(((1<<j-i+1)-1)<<i);
初始化低j-i+1位为1，左移i位，01互换，i~j设为0，其他位保留
2.a|=n1<<i;
将被置为0的i~j位次被赋值为n1对应的二进制数
3.a&=~(((1<<n-m+1)-1)<<m);
初始化低n-m+1位为1，左移m位，01互换，m~n设为0，其他位保留
4.a|=n2<<m;
将被置为0的m~n位次被赋值为n2对应的二进制数
e.3. 将1个16位无符号数a的高低字节互换
1.unsigned short a,ans;
2.scanf("%hu",&a);
3.ans=((a&0XFF00)>>8)|((a&OXFF)<<8);
取出a的高八位数：0XFF00：0...0 1111 1111 0000 0000
取出a的低八位数：0XFF ：0...0 1111 1111
4.printf("%hu\n",ans);
att. ~a+1可实现对变量a的取相反数（同补码）
att. x=x^y^y^z^z…;奇数次数据即为异或结果
*/
;//简单指针示例
/*
in main()
{
in a;
in b;
in* p1 = &a;//等价于：in* p1; *p1 = &a;
in* p2 = &b;//等价于：in* p2; *p2 = &b;
sc_in(a);
sc_in(b);
pr_inn(a);
pr_inn(b);
pr_inn(&a);//变量a的地址
pr_inn(&b);//变量b的地址
pr_inn(p1);//p1未解除引用，表示a的地址
pr_inn(p2);//p2未解除引用，表示b的地址
pr_inn(*p1);//p1解除引用，表示a所在地址内的值
pr_inn(*p2);//p2解除引用，表示b所在地址内的值
ch c;
ch d;
ch* p3 = &c;
ch* p4 = &d;
getchar();
sc_ch(c);//@a
getchar();
sc_ch(d);//@b
pr_chn(c);//#a
pr_chn(d);//#b
pr_chn(&c);//#?
pr_chn(&d);//#?
pr_inn(&c);//#address
pr_inn(&d);//#address
pr_chn(p3);//#?
pr_chn(p4);//#?
pr_inn(p3);//#address
pr_inn(p4);//#address
pr_chn(*p3);//#a
pr_chn(*p4);//#b
pr_inn(*p3);//#ascii
pr_inn(*p4);//#ascii
}
*/
;//多级指针示例
/*
in main()
{
in a;
sc_in(a);//@1
in* p1 = &a;
in* p2 = &*p1;
in* p3 = &*p2;
in* p2_1 = &(*p1);
in* p3_1 = &(*p2);
pr_inn(p1);//#address1 a
pr_inn(p2);//#address1 a
pr_inn(p3);//#address1 a
pr_inn(p2_1);//#address1 a
pr_inn(p3_1);//#address1 a
pr_inn(*p1);//#1
pr_inn(*p2);//#1
pr_inn(*p3);//#1
pr_inn((in*)(*p1));//#1
pr_inn((in*)(*p2));//#1
pr_inn((in*)(*p3));//#1
in* P1 = *&p1;
in* P2 = &*&a;
pr_inn(P1);//#1address1 a
pr_inn(P2);//#1address1 a
pr_inn(*P1);//#1
pr_inn(*P2);//#1
in** q1 = &p1;
in** q2 = &p2;
in*** q3 = &q1;
in*** q4 = &q2;
pr_inn(&p1);//#address2 p1
pr_inn(q1);//#address2 p1
pr_inn(&p2);//#address3 p2
pr_inn(q2);//#address3 p2
pr_inn(&q1);//#address3 q1
pr_inn(q3);//#address4 q1
pr_inn(&q2);//#address3 q2
pr_inn(q4);//#address5 q2
pr_inn(*q1);//#address1 a *q1 p1 &a
pr_inn(*q2);//#address1 a *q2 p2 &a
pr_inn(*q3);//#address2 p1 *q3 q1 &p1
pr_inn(*q4);//#address3 p2 *q4 q2 &p2
pr_inn(**q1);//#1 **q1 *p1 a 1
pr_inn(**q2);//#1 **q2 *p2 a 1
pr_inn(***q3);//#1 ***q3 **q1 *p1 a 1
pr_inn(***q4);//#1 ***q4 **q2 *p2 a 1
}
*/
;//函数指针示例
/*
in add(in a, in b)
{
return a + b;
}
in main()
{
in(*pfn)(in, in);//定义函数指针*pfn
pfn = add;//pfn指向函数add，*pfn解除引用代替实现add的效果
in* pa;//定义指针*pa
in* pb;//定义指针*pb
in a, b;
sc_in(a);//@1
sc_in(b);//@2
pa = &a;//将变量a的地址传给pa，*pa解除引用后对应的是变量a所在地址内的值
pb = &b;//将变量b的地址传给pb，*pb解除引用后对应的是变量b所在地址内的值
pr_inn(*pa + *pb);
in ans1 = (pfn(a, b));
in ans2 = ((*pfn)(a, b));
pr_inn(ans1);//#3
pr_inn(ans2);//#3
pr_inn(add);//address1
pr_inn(pfn);//address1
pr_inn(&add);//address1
pr_inn(*pfn);//address1
return 0;
}
*/
;//一维数组指针示例
/*
in main()
{
in A[100] = { 0 };
for (in i = 0; i < 100; i++)
{
A[i] = i;
}
pr_inn(sizeof(A));//=100
in size = sizeof(A) / 4;
pr_inn(A);//#address=x即数组首地址
pr_inn(A + 0);//#address=x+0*4 A[0]的地址
pr_inn(A + 1);//#address=x+1*4 A[1]的地址
pr_inn(A + 2);//#address=x+2*4 A[2]的地址
pr_inn(A + size - 1);//#address=x+99*4 A[99]的地址
pr_inn(A + size + 0);//#address=x+100*4 越界的地址
pr_inn(*A);//#0
pr_inn(*(A + 0));//#0
pr_inn(*(A + 1));//#1
pr_inn(*(A + 2));//#2
pr_inn(*(A + size - 1));//#99
pr_inn(*(A + size + 0));//address random
in* p = A;
pr_inn(p);//#address=x
pr_inn(*p);//#0
pr_inn(p + 1);//#address=x+1*4 移动1字节
pr_inn(*p + 1);//#A[0]+1;
pr_inn(*(p + 1));//#A[0+1];
for (in i = 0; i < 5; i++)
{
sc_in(*(p + i));
}
for (in i = 0; i < 5; i++)
{
pr_inn(*(p + i));
}
}
*/
;//字符数组指针示例
/*in main()
{
ch C1[101];
fgets(C1, sizeof(C1), stdin);//@abc
in len1 = strlen(C1);//strlen({'a','b','c','\n'})
pr_inn(len1);//#4
for (in i = 0; i < len1; i++)
{
if (*(C1 + i) == '\n')
{
pr("ENTER");
}
else
{
pr_in(*(C1 + i));
pr_ch(*(C1 + i));
}
}
pr("\n");
ch C2[101] = { 'a','b','c' };
ch C3[101] = { 'a','b','c','\0' };
ch C4[101] = "abc";
in len2 = strlen(C2);//strlen({'a','b','c'})
in len3 = strlen(C3);//strlen({'a','b','c'})
in len4 = strlen(C4);//strlen("abc")
pr_inn(len2);//#3
pr_inn(len3);//#3
pr_inn(len4);//#3
pr_ch(*(C2 + 0));//#'a'
pr_ch(*(C2 + 1));//#'b'
pr_ch(*(C2 + 2));//#'c'
pr_ch(*(C2 + 100));//#nothing
pr("\n");
}
*/
;//字符串处理示例
/*
in main()
{
ch str1[101] = "";
ch str2[101] = "";
ch buf1[201] = "";//缓冲数组
ch buf2[201] = "";//缓冲数组
ch buf3[201] = "";//缓冲数组
while (fgets(str1, sizeof(str1), stdin) != NULL && fgets(str2, sizeof(str2), stdin) != NULL)//两行不定组
{//@abc @abc
in len1 = strlen(str1);
in len2 = strlen(str2);
pr_inn(len1);//#4
pr_inn(len2);//#4
str1[strcspn(str1, "\n")] = '\0';//替换fgets输入字符串时末尾的换行符
str2[strcspn(str2, "\n")] = '\0';//替换fgets输入字符串时末尾的换行符
in len1_1 = strlen(str1);
in len2_1 = strlen(str2);
pr_inn(len1_1);//#3
pr_inn(len2_1);//#3
pr_stn(str1);//#abc
pr_stn(str1 + 1);//#ab
pr_stn(str1 + 2);//#c
pr_stn(str1 + 3);//#nothing
pr_stn(str1 + 4);//#notning
pr_stn(str1 + strlen(str1));//#notning
pr_stn(str1 + strlen(str1) - 1);//#'c'
pr_stn(str1 + strlen(str1) + 1);//#notning
in len3 = strlen(str1 + 1);
in len4 = strlen(str1 + 2);
pr_inn(len3);//#3-1=2
pr_inn(len4);//#3-2=1
pr_inn(strchr(str1, 'c'));//返回字符c在str1中首次出现的str1中的地址
pr_inn(strchr(str1, 'd'));//#0即未找到
pr_chn(*(strchr(str1, 'c')));//#'c'
pr_inn(strstr(str1, str2));//返回str2在str1中首次出现的str1中的地址
pr_inn(str1);//#address 'a'
pr_chn(*str1);//#'a'
pr_inn(strstr(str1, "abc"));//#address 'a'
pr_inn(strstr(str1, "ab"));//#address 'a'
pr_inn(strstr(str1, "bc"));//#address 'c'
pr_inn(strstr(str1, "ac"));//#0即未找到
pr_chn(*(strstr(str1, "abc")));//#'a'
strcpy(buf1, str1);//将str1复制到buf1
pr_stn(buf1);//#abc
strcpy(buf2, str2);
pr_stn(buf2);
strncpy(buf3, "hello!", 5);//复制前5位
pr_stn(buf3);
strcat(buf1, str1);//将str1拼接到buf1
pr_stn(buf1);//#abcabc
strcat(buf2, str2);
pr_stn(buf2);
strcat(buf1, "a");
pr_stn(buf1);//#abcabca
strcat(buf2, "b");
pr_stn(buf2);//#abcabcb
strncat(buf3, "world!", 5);//剪贴前5位
pr_stn(buf3);
in cmp1 = strcmp(buf1, buf2);//首个相异的字符对为(a,b) in(a)<in(b) =-1
in cmp2 = strcmp(buf2, buf1);//首个相异的字符对为(b,a) in(b)>in(a) =1
in cmp3 = strcmp(str1, str2);//完全相等 =0
in cmp4 = strcmp(str2, str1);//完全相等 =0
in cmp5 = strncmp(buf1, buf2, strlen(buf2));//比较前strlen个
in cmp6 = strncmp(buf1, buf2, strlen(buf2) - 1);//比较前srtlen-1个
in cmp7 = strncmp(buf1, buf2, strlen(buf2) + 1);//越界
in cmp8 = strncmp(buf1, buf2, strlen(buf2) + 9);//越界
pr_inn(cmp1);//#-1
pr_inn(cmp2);//#1
pr_inn(cmp3);//#0
pr_inn(cmp4);//#0
pr_inn(cmp5);//#-1
pr_inn(cmp6);//#0
pr_inn(cmp7);//#-1
pr_inn(cmp8);//#-1
}
}
*/
;//字符串解构示例：sscanf
/*
in main()
{
ch chr1;
ch chr2;
in num1;
in num2;
ch str1[]= "a:b:1:2";
sscanf(str1, "%c:%c:%d:%d", &chr1, &chr2, &num1, &num2);
pr_chn(chr1);//#a
pr_chn(chr2);//#b
pr_inn(num1);//#1
pr_inn(num2);//#2
ch* pc1 = &chr1;
ch* pc2 = &chr2;
in* pn1 = &num1;
in* pn2 = &num2;
sscanf(str1, "%c:%c:%d:%d", pc1, pc2, pn1, pn2);
//sscanf以非空格等字符隔断不能解构字符串
pr_chn(chr1);
pr_chn(chr2);
pr_inn(num1);
pr_inn(num2);
ch buf1[11] = "";
ch buf2[11] = "";
ch buf3[11] = "";
ch str2[] = "aaa bbb ccc";
sscanf(str2, "%s %s %s", buf1, buf2, buf3);
//sscanf以空格等隔断可以解构含空格字符串
pr_stn(buf1);//#aaa
pr_stn(buf2);//#bbb
pr_stn(buf3);//#ccc
ch buf4[11] = "";
ch buf5[11] = "";
ch buf6[11] = "";
ch buf7[11] = "";
ch str3[] = "aaa:bbb:ccc";
sscanf(str3, "%[^:]:%[^:]:%[^:]", buf4, buf5, buf6);
//sscanf以%[^ ]为格式可隔断字符串且^后字符为终止符
// 例如%[^:]可取出':'之前且其他隔断之后的字符串
pr_stn(buf4);//#aaa
pr_stn(buf5);//#bbb
pr_stn(buf6);//#ccc
sscanf(str3, "aaa:%[^:]:ccc", buf7);
pr_stn(buf7);//#bbb
ch buf8[11] = "";
ch buf9[11] = "";
ch buf10[11] = "";
ch buf11[11] = "";
ch str4[] = "aaabbbccc";
sscanf(str4, "aaa%[^c]ccc", buf8);
//aaa格式化对应aaa
//%[^c]取第一个c之前的字符串bbb
//ccc格式化对应ccc
sscanf(str4, "%[^b]%[^c]%s", buf9, buf10, buf11);
//%[^b]取第一个b之前的字符串aaa
//%[^c]取第一个c之前的字符串bbb
//%s 取最后无法有效截断的ccc
pr_stn(buf9); //#aaa
pr_stn(buf10);//#bbb
pr_stn(buf11);//#ccc
in num3;
in num4;
in num5;
in num6;
in num7;
in num8;
ch str5[] = "aaa123ccc";
ch str6[] = "aaabccc";
sscanf(str5, "aaa%dccc", &num3);
//字符串内解构某整数
sscanf(str5, "aaa %d ccc", &num4);
//此处空格不影响解构
sscanf(str5, "aaa%[^c]ccc", &num5);
//类型不一致而错误！
sscanf(str5, "aaa%dddd", &num6);
//后端对应错误但仍能取出
sscanf(str5, "ddd%dccc", &num7);
//前端对应错误则不能取出
sscanf(str6, "aaa%dccc", &num8);
pr_inn(num3);//#123
pr_inn(num4);//#123
pr_inn(num5);//#3355185(special)
pr_inn(num6);//#123
pr_inn(num7);//address1
pr_inn(num8);//address1
}
*/
;//数转字符串示例：sprintf
/*
in main()
{
in num1 = 123;
in num2 = 456;
ch str1[11] = "";
sprintf(str1, "%d", num1);
pr_stn(str1);//首次写入#123
sprintf(str1, "%d", num2);
pr_stn(str1);//覆盖写入#456
sprintf(str1, "%d%d", num1, num2);
pr_stn(str1);//拼接两个num#123456
sprintf(str1, "%d%c", num1, 'a');
pr_stn(str1);//拼接数字和字符#123a
sprintf(str1, "%d%s", num1, "abc");
pr_stn(str1);//拼接数字和字符串#123abc
sprintf(str1, "%d+%d", num1, num2);
pr_stn(str1);//格式化拼接#123+456
sprintf(str1, "123");
pr_stn(str1);//#123
snprintf(str1, 4, "abc");
pr_stn(str1);//#abc
snprintf(str1, 3, "abc");
pr_stn(str1);//#ab
snprintf(str1, 2, "abc");
pr_stn(str1);//#a
snprintf(str1, 1, "abc");
pr_stn(str1);//#nothing
}
*/
;//字符串转数示例：atoi & strtoll
/*
in main()
{
//atoi取带符号位的数字构成整型数字
ch str1[] = "123abc";//atoi到a截断
ch str2[] = "abc123";//atoi失败返回0
ch str3[] = " 123";//atoi跳过首空格
ch str4[] = "-123"; //atoi支持符号位
ch str5[] = "+123"; //atoi支持符号位
ch str6[] = "+1+2"; //非符号位终止
ch str7[] = " 1 2"; //非首空格终止
in num1 = atoi(str1);
in num2 = atoi(str2);
in num3 = atoi(str3);
in num4 = atoi(str4);
in num5 = atoi(str5);
in num6 = atoi(str6);
in num7 = atoi(str7);
pr_inn(num1);//#123
pr_inn(num2);//#0
pr_inn(num3);//#123
pr_inn(num4);//#-123
pr_inn(num5);//#123
pr_inn(num6);//#1
pr_inn(num7);//#1
pr_n;
//strtol在atoi基础上可取出剩余部分
ch str8[] = "123abc";
ch str9[] = "abc123";
ch str10[] = " 123";
ch str11[] = "-123";
ch str12[] = "+123";
ch str13[] = "+1+2";
ch str14[] = " 1 2";
ch* p1;
ch* p2;
ch* p3;
ch* p4;
ch* p5;
ch* p6;
ch* p7;
ll num8 = strtoll(str8, &p1, 10);
ll num9 = strtoll(str9, &p2, 10);
ll num10 = strtoll(str10, &p3, 10);
ll num11 = strtoll(str11, &p4, 10);
ll num12 = strtoll(str12, &p5, 10);
ll num13 = strtoll(str13, &p6, 10);
ll num14 = strtoll(str14, &p7, 10);
//#strtol仅支持long型
pr_inn(num8);//#123
pr_inn(num9);//#0
pr_inn(num10);//#123
pr_inn(num11);//#-123
pr_inn(num12);//#123
pr_inn(num13);//#1
pr_inn(num14);//#1
pr_n;
pr_stn(p1);//#abc
pr_stn(p2);//#abc123
pr_stn(p3);//#nothing
pr_stn(p4);//#nothing
pr_stn(p5);//#nothing
pr_stn(p6);//#+2
pr_stn(p7);//# 2
pr_n;
pr_chn(*p1);//#a
pr_chn(*p2);//#a
pr_chn(*p3);//#nothing
pr_chn(*p4);//#nothing
pr_chn(*p5);//#nothing
pr_chn(*p6);//#+
pr_chn(*p7);//#' '
}
*/
;//经典指针应用：swap
/*
void swap(in *p1, in *p2)
{//in* p1 = a; in* p2 = b
in temp = *p1;
*p1 = *p2;
*p2 = temp;
}//交换地址对应的内容
in main()
{
in a;
in b;
in* pa = &a;
in* pb = &b;
sc_in(a);
sc_in(b);
swap(&a, &b);//取址传入
pr_inn(a);
pr_inn(b);
swap(pa, pb);//取址传入
pr_inn(a);
pr_inn(b);
}
*/
;//舍入函数示例
/*
in main()
{
db num1 = 0.1;
db num2 = 0.5;
db num3 = -0.1;
db num4 = -0.5;
pr_inn(round(num1));//#0
pr_inn(round(num2));//#0
pr_inn(round(num3));//#0
pr_inn(round(num4));//#0
pr_dbn(round(num1));//#0.000000
pr_dbn(round(num2));//#1.000000
pr_dbn(round(num3));//#-0.000000
pr_dbn(round(num4));//#-1.000000
pr_dbn(round(num3) + 0.0);//#0.000000
pr_inn(floor(num1));//#0
pr_inn(floor(num2));//#0
pr_inn(floor(num3));//#0
pr_inn(floor(num4));//#0
pr_dbn(floor(num1));//#0.000000
pr_dbn(floor(num2));//#0.000000
pr_dbn(floor(num3));//#-1.000000
pr_dbn(floor(num4));//#-1.000000
pr_inn(ceil(num1));//#0
pr_inn(ceil(num2));//#0
pr_inn(ceil(num3));//#0
pr_inn(ceil(num4));//#0
pr_dbn(ceil(num1));//#1.000000
pr_dbn(ceil(num2));//#1.000000
pr_dbn(ceil(num3));//#-0.000000
pr_dbn(ceil(num4));//#-0.000000
pr_dbn(ceil(num3) + 0.0);//#0.000000
pr_dbn(ceil(num4) + 0.0);//#0.000000
//正数有效
pr_inn((int)(num1 + 0.5));//#0
pr_inn((int)(num2 + 0.5));//#1
//负数无效
pr_inn((int)(num3 + 0.5));//#0
pr_inn((int)(num4 + 0.5));//#0
}
*/
;//判断函数示例
/*
in main()
{
pr_inn(isdigit(1)); //#0
pr_inn(isdigit('1')); //#非0 4
pr_n;//数字否
pr_inn(isalpha('a')); //#非0 2
pr_n;//字母否
pr_inn(isalnum('1')); //#非0 4
pr_inn(isalnum('a')); //#非0 2
pr_n;//数字或字母否
pr_inn(islower('a')); //#非0 2
pr_inn(isupper('A')); //#非0 1
pr_n;//小写或大写否
pr_inn(isblank(' ')); //#非0 64
pr_inn(isblank('\t'));//#非0 64
pr_n;//空格或水平制表否
pr_inn(iscntrl('\n'));//#非0 32
pr_inn(iscntrl('\r'));//#非0 32
pr_inn(iscntrl('\v'));//#非0 32
pr_inn(iscntrl('\f'));//#非0 32
pr_n;//控制字符否
pr_inn(isspace(' ')); //#非0 8
pr_inn(isspace('\t'));//#非0 8
pr_inn(isspace('\n'));//#非0 8
pr_inn(isspace('\r'));//#非0 8
pr_inn(isspace('\v'));//#非0 8
pr_inn(isspace('\f'));//#非0 8
pr_n;//空白字符否
pr_inn(ispunct('.')); //#非0 16
pr_inn(ispunct(',')); //#非0 16
pr_n;//标点字符否（广义）
pr_inn(isprint('1')); //#非0 4
pr_inn(isprint('a')); //#非0 2
pr_inn(isprint('.')); //#非0 16
pr_inn(isprint(' ')); //#非0 64
pr_inn(isprint('\t'));//#0
pr_n;//可打印字符否（含空格）
pr_inn(isgraph('1')); //#非0 4
pr_inn(isgraph('a')); //#非0 2
pr_inn(isgraph('.')); //#非0 16
pr_inn(isgraph(' ')); //#0
pr_inn(isgraph('\t'));//#0
pr_n;//图形字符否（不含空格）
pr_inn(isxdigit('1'));//#非0 128
pr_inn(isxdigit('f'));//#非0 128
pr_inn(isxdigit('F'));//#非0 128
pr_n;//十六进制数字否（大小写）
db x = 0.0;
db y = 1.0 / x;
db z = sqrt(-1.0);
pr_inn(isfinite(x)); //#1 有限数否
pr_inn(isinf(y)); //#1 无穷数否
pr_inn(isnan(z)); //#1 错误否
pr_inn(signbit(-0.0));//#1 符号位为负否
}
*/
;//转换函数示例
/*
in main()
{
pr_chn(toupper('a'));//#A
pr_chn(tolower('A'));//#a
//其他则保持不变输出
}
*/
最新发布
本文详细讲解了C和C++中宏定义#define的用法，并深入探讨了printf, sprintf及strchr等函数的应用场景及常见错误。通过本文的学习，读者可以更好地掌握这些基础但重要的编程元素。
扫一扫
240
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
