封装函数: 判断闰年和平年
该函数判断传入的年份是否是闰年和平年，通过返回值表示结果。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
#include <stdio.h>
//函数声明
int GetYearSate(int year);
int main()
{
int year;
printf("请输入年份:");
scanf("%d",&year);
//判断闰年和平年
if(GetYearSate(year))
{
printf("平年.\n");
}
else
{
printf("闰年.\n");
}
return 0;
}
/*
函数功能: 判断平年闰年
返回值: 0表示闰年 1表示平年
*/
int GetYearSate(int year)
{
if((year%4==0 && year%100!=0)||(year%400==0))
{
return 0;
}
return 1;
}
|
封装函数: 字符串查找(参考strstr)
第一步查看帮助: man strstr
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
#include <stdio.h>
#include <string.h> //声明函数的
char *my_strstr(char *src_str,char *find_str);
int main()
{
char src_str[100];//"123456789"
char find_str[100];
printf("请输入字符串:");
scanf("%s",src_str);
printf("请输入查找的字符串:");
scanf("%s",find_str);
//strstr() //查找到指定的字符串，会返回查找字符串在源字符串里的首地址
printf("查找的字符串结果:%s\n",strstr(src_str,find_str));
printf("查找的字符串结果:%s\n",my_strstr(src_str,find_str));
return 0;
}
//函数功能: 字符串查找函数
//返回值: 返回查找到的字符串地址
char *my_strstr(char *src_str,char *find_str)
{
int src_len;
int find_len;
int i,j;
src_len=strlen(src_str);
find_len=strlen(find_str);
for(i=0;i<src_len;i++)
{
for(j=0;j<find_len;j++)
{
if(src_str[i+j]!=find_str[j])break;
}
//判断是否查找成功
if(j==find_len)
{
//return &src_str[i];
return src_str+i;
}
}
return NULL;
}
|
封装函数: 字符串比较(参考strcmp)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
#include <stdio.h>
#include <string.h> //声明函数的
int my_strcmp(char *s1,char *s2);
int main()
{
char str1[100];//"123456789"
char str2[100];
printf("请输入字符串1:");
scanf("%s",str1);
printf("请输入字符串2:");
scanf("%s",str2);
//int strcmp(const char *s1, const char *s2);
//比较两个字符串是否相等。通过返回值表示。
printf("比较字符串的结果:%d\n",strcmp(str1,str2));
printf("比较字符串的结果:%d\n",my_strcmp(str1,str2));
return 0;
}
/*
函数功能: 比较两个字符串是否相等
返回值: 0表示相等 1表示不相等
*/
int my_strcmp(char *s1,char *s2)
{
while(*s1!='\0' && *s2!='\0')
{
if(*s1!=*s2)break;
s1++;
s2++;
}
if(*s1=='\0'&&*s2=='\0')return 0;
return 1;
}
|
封装函数: 字符串拼接(参考strcat)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
#include <stdio.h>
#include <string.h> //声明函数的
char *my_strcat(char *s1,char *s2);
int main()
{
char str1[100];//"123456789"
char str2[100];
printf("请输入字符串1:");
scanf("%s",str1);
printf("请输入字符串2:");
scanf("%s",str2);
//strcat 字符串拼接函数，拼接之后返回源字符串的首地址
// printf("拼接的结果:%s\n",strcat(str1,str2));
printf("拼接的结果:%s\n",my_strcat(str1,str2));
return 0;
}
//函数功能: 字符串拼接
char *my_strcat(char *s1,char *s2)
{
char *p=s1; //记录源字符串的首地址
while(*s1 != '\0'){s1++;} //偏移到结尾
while(*s2!='\0')
{
*s1=*s2;
s2++;
s1++;
}
*s1='\0';
return p;
}
|
封装函数: 字符串转整数(参考atoi)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
#include <stdio.h>
#include <string.h>
int my_atoi(char *str);
int main()
{
char buff[100];
printf("请输入一个整数字符串:");
scanf("%s",buff);
//字符串转整数
printf("转换结果:%d\n",atoi(buff));
printf("转换结果:%d\n",my_atoi(buff));
return 0;
}
/*
函数功能: 字符串转整数
函数形参: 传入待转换的字符串(0~9)
返回值: 返回转换的整数结果,如果转换失败返回0
*/
//"123ABC"
int my_atoi(char *str)
{
int data=0;
while(*str!='\0')
{
if(*str>='0' && *str<='9')
{
data*=10; //0 10 120
data+=*str-'0';//1 12 123
}
else
{
break;
}
str++;
}
return data;
}
|
封装函数: 字符串转浮点数(参考atof)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
|
“123.456789” 456789—>0.456789
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
double my_pow(double x,int y);
double my_atof(char *str,int cnt);
int main()
{
char buff[100];
printf("请输入一个浮点数字符串:");
scanf("%s",buff);
//字符串转浮点数
printf("转换结果:%lf\n",atof(buff));
printf("转换结果:%lf\n",my_atof(buff,3));
return 0;
}
/*
函数功能: 字符串转浮点数
函数形参: str是传入待转换的字符串 cnt是保留的小数点位数
返回值: 返回转换的整数结果,如果转换失败返回0
*/
//"123.456 123"
double my_atof(char *str,int cnt)
{
int data=0;
int cnt_f=0;
double data_f=0.0;
while(*str!='\0' && *str!='.')
{
if(*str>='0' && *str<='9')
{
data_f*=10;
data_f+=*str-'0';
}
else
{
break;
}
str++;
}
str++; //跳过 "." "123.456789"
while(*str!='\0' && cnt_f!=cnt)
{
if(*str>='0' && *str<='9')
{
data*=10;
data+=*str-'0';
cnt_f++; //记录小数部分数量
}
else
{
break;
}
str++;
}
//合成浮点数 "123.456"
if(cnt>cnt_f)
{
cnt=cnt_f;
}
data_f+=data*my_pow(0.1,cnt);
return data_f;
}
//函数功能:计算x的y次方
//my_pow(2,3);
double my_pow(double x,int y)
{
double tmp=1.0;
int i;
for(i=0;i<y;i++)
{
tmp=tmp*x;//2.0 4.0 8.0
}
return tmp;
}
|
封装函数: 整数转字符串 123 “123”
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void int_to_str(char *str,int data);
int main()
{
int data;
char buff[100];
printf("请输入一个整数:");
scanf("%d",&data);
//整数转字符串
int_to_str(buff,data);
printf("buff=%s\n",buff);
return 0;
}
/*
函数功能: 整数转字符串
*/
void int_to_str(char *str,int data)
{
char buff[100]; //存放第一次分离的数据
int i=0;
int j=0;
while(data) //123
{
buff[i]=data%10+'0';
data=data/10;
i++;
}
for(j=0;j<i;j++)
{
str[j]=buff[i-1-j];
}
str[j]='\0';
}
//函数功能:计算x的y次方
//my_pow(2,3);
double my_pow(double x,int y)
{
double tmp=1.0;
int i;
for(i=0;i<y;i++)
{
tmp=tmp*x;//2.0 4.0 8.0
}
return tmp;
}
|
封装函数: 浮点数转字符串 123.456 – “123.456”
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int my_pow(int x,int y);
void int_to_str(char *str,int data);
void double_to_str(char *str,double data_f,int cnt);
int main()
{
double data;
char buff[100];
printf("请输入一个浮点数:");
scanf("%lf",&data);
double_to_str(buff,data,5);
printf("buff=%s\n",buff);
return 0;
}
/*
函数功能: 浮点数转字符串
*/
void double_to_str(char *str,double data_f,int cnt)
{
char buff[50]; //存放第一次分离的数据
int i=0;
int j=0;
int n=0;
int data_i1;
int data_i2;
double temp_f;
/*1. 分离整数部分*/ //123.3
data_i1=data_f; //123
temp_f=data_f-data_i1;
data_i2=temp_f*my_pow(10,cnt); //456
/*2. 转换整数部分*/
while(data_i1)
{
buff[i]=data_i1%10+'0';
data_i1=data_i1/10;
i++;
}
/*3. 将整数部分放到数组里*/
for(j=0;j<i;j++)
{
str[j]=buff[i-1-j];
}
str[j]='.';
/*4. 转换小数部分*/ // "123.456"
while(data_i2)
{
buff[n]=data_i2%10+'0';
data_i2=data_i2/10;
n++;
}
/*5. 将小数部分放到数组里*/
for(j=0;j<n;j++)
{
str[j+i+1]=buff[n-1-j];
}
str[j+i+1]='\0';
}
//函数功能:计算x的y次方
//my_pow(2,3);
int my_pow(int x,int y)
{
int tmp=1;
int i;
for(i=0;i<y;i++)
{
tmp=tmp*x;//2.0 4.0 8.0
}
return tmp;
}
浮点数转字符串 123.456 -- “123.456”
float a=123.456;
int b=a; //b=123
a=a-b; //a=0.456 10*10*10
|
封装函数: 判断回文字符串
该函数判断传入的字符串是否是回文，通过返回值表示结果。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int func(char *p);
int main()
{
char buff[100];
printf("输入字符串:");
scanf("%s",buff);
if(func(buff))printf("回文.\n");
else printf("不是回文.\n");
return 0;
}
//函数功能: "123" "121"
int func(char *p)
{
int i;
int len;
len=strlen(p);
for(i=0;i<len/2;i++)
{
if(p[i]!=p[len-1-i])break;
}
if(i==len/2)return 1; //回文
return 0; //不是回文
}
|
封装函数: 字符串替换
将源字符串里指定的单词替换成指定单词。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void str_func(char *str1,char *str2,char *str3);
int main()
{
char str1[100];
char str2[100];
char str3[100];
/*1.准备数据*/
printf("输入源字符串:");
scanf("%s",str1);
printf("输入查找的字符串:");
scanf("%s",str2);
printf("输入替换的字符串:");
scanf("%s",str3);
str_func(str1,str2,str3);
/*4. 完成字符串打印*/
printf("str1=%s\n",str1);
return 0;
}
//"123A789" ""
void str_func(char *str1,char *str2,char *str3)
{
int str1_len=0;
int str2_len=0;
int str3_len=0;
int i,j;
int cnt=0;
/*2. 计算长度*/
str1_len=strlen(str1);
str2_len=strlen(str2);
str3_len=strlen(str3);
/*3. 字符串替换*/
for(i=0;i<str1_len;i++)
{
//查找字符串
for(j=0;j<str2_len;j++)
{
if(str1[i+j]!=str2[j])break;
}
//如果查找成功就进行替换
if(j==str2_len)
{
//总长度变短了
if(str2_len>str3_len)
{
cnt=str2_len-str3_len; //差值
//完成数据向前移动--覆盖
for(j=i+str2_len-cnt;j<str1_len;j++)
{
str1[j]=str1[j+cnt];
}
str1[str1_len-cnt]='\0';
}
//总长度变长了
else if(str2_len<str3_len)
{
cnt=str3_len-str2_len; //差值
//完成数据向后移动
for(j=str1_len;j>=i+str2_len;j--)
{
str1[j+cnt]=str1[j];
}
str1[str1_len+cnt]='\0';
}
//替换
for(j=0;j<str3_len;j++)
{
str1[i+j]=str3[j];
}
//重新计算长度
str1_len=strlen(str1);
}
}
}
|
封装函数: 清除二维数组的指定行
该函数功能可以通过传入的参数，清除指定二维数组的指定一行数据为0.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void clear(int (*p)[5],int a,int b);
int main()
{
int i,j;
int buff[][5]=
{
{1,2,3,4,5},
{11,12,13,14,15},
{21,22,23,24,25}
};
printf("源数据:\n");
for(i=0;i<sizeof(buff)/sizeof(buff[0]);i++)
{
for(j=0;j<sizeof(buff[0])/sizeof(buff[0][0]);j++)
{
printf("%d ",buff[i][j]);
}
printf("\n");
}
clear(buff,888,2);
printf("清除之后的数据:\n");
for(i=0;i<sizeof(buff)/sizeof(buff[0]);i++)
{
for(j=0;j<sizeof(buff[0])/sizeof(buff[0][0]);j++)
{
printf("%d ",buff[i][j]);
}
printf("\n");
}
return 0;
}
void clear(int (*p)[5],int a,int b)
{
int i;
for(i=0;i<sizeof(p[0])/sizeof(p[0][0]);i++)
{
p[b][i]=a;
}
}
|
封装函数:字符串里所有大写字母互相替换
将字符串里所有大写字母全部换成小写字母。或者小写字母全部换成大写字母。可以通过形参进行区分。 该功能广泛用在验证码功能上。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void func(char *str,int flag);
int main()
{
char buff[100];
printf("从键盘上输入字符串:");
scanf("%s",buff);
printf("源字符串:%s\n",buff);
func(buff,0);
printf("大写转换小写:%s\n",buff);
func(buff,1);
printf("小写转大写:%s\n",buff);
return 0;
}
//函数功能: 大写小写转换
//flag=0表示大写转换小写 =1表示小写转大写
void func(char *str,int flag)
{
int data;
while(*str!='\0')
{
if(flag)
{
if(*str>='a'&& *str<='z') //小写
{
*str=*str-32;
}
}
else
{
if(*str>='A'&& *str<='Z') //小写
{
*str=*str+32;
}
}
str++;
}
}
|
封装GPS解码函数:可以传入GPS格式的字符串
该函数可以传入GPS格式的字符串，在函数里完成所有数据解码输出。经度、纬度、卫星的数量、时间
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
char gps_buff[]=
{
"$GNGGA,114955.000,2842.4158,N,11549.5439,E,1,05,3.8,54.8,M,0.0,M,,*4F"
"$GNGLL,2842.4158,N,11549.5439,E,114955.000,A,A*4D"
"$GPGSA,A,3,10,31,18,,,,,,,,,,5.7,3.8,4.2*37"
"$BDGSA,A,3,07,10,,,,,,,,,,,5.7,3.8,4.2*2A"
"$GPGSV,3,1,10,10,49,184,42,12,16,039,,14,54,341,,18,22,165,23*7B"
"$GPGSV,3,2,10,22,11,318,,25,51,055,,26,24,205,,29,13,110,*7C"
"$GPGSV,3,3,10,31,50,287,36,32,66,018,*7F"
"$BDGSV,1,1,04,03,,,07,05,,,29,07,79,246,33,10,52,232,19*62"
"$GNRMC,114955.000,A,2842.4158,N,11549.5439,E,0.00,44.25,061117,,,A*4D"
"$GNVTG,44.25,T,,M,0.00,N,0.00,K,A*14"
"$GNZDA,114955.000,06,11,2017,00,00*47"
"$GPTXT,01,01,01,ANTENNA OK*35"
};
/*
函数功能: 根据逗号位置提取数据
函数参数:
char *gps_src GPS源字符串地址
char *buff 存放提取的数据
char *find_head 查找的GPS数据头
int cnt 逗号的偏移量
返回值：提取的字节数。
*/
int GPS_GetData(char *gps_src,char *find_head,char *buff,int cnt)
{
char *p;
int number=0; //提取的数量
int a=0;
p=strstr(gps_src,find_head);
if(p!=NULL)
{
//查找逗号的位置
while(*p!='\0')
{
if(*p==',')a++; //记录逗号的数量
if(a==cnt)break; //逗号找成功了
p++;
}
p++; //跨过当前逗号
//提取数据
while(*p!='\0')
{
if(*p==',')break; //遇到逗号停止提取数据
buff[number]=*p;
p++;
number++;
}
buff[number]='\0';
}
return number;
}
int main()
{
char buff[100];
GPS_GetData(gps_buff,"$GNGGA",buff,2);
printf("纬度:%s\n",buff);
GPS_GetData(gps_buff,"$GNGGA",buff,4);
printf("经度:%s\n",buff);
return 0;
}
|
封装函数: 将十进制整数转为16进制输出(字符串形式)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
#include <stdio.h>
//定义16进制的数据,方便输出
char hex_val[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
int main()
{
int number=0;
int a[100];
int i=0;
int data;
/*1. 输入十进制的整数*/
printf("输入一个整数:");
scanf("%d",&number);
/*2. 16进制最大值是15-0xFF,取余进行分离*/
while(number>0)
{
data=number%16;
a[i]=data;
number=number/16;
i++;
}
printf("输入整数的十六进制数: 0x");
/*3. 输出对应的16进制格式*/
for(i=i-1;i>=0;i--)
{
printf("%c",hex_val[a[i]]);
}
printf("\n");
}
|
|
