通过一个实际小应用，记录C语言中4个字符串操作相关的函数及其用法：

  • strtok_r
  • strstr
  • strtok
  • atoi

问题引出

先贴一段变量定义：

1
char str[] = "led,100,0,80,15";//一个字符串，第一个逗号前的字符串设定为某个命令，后面的是参数

假设某种应用场景，接收到一串字符串，如上面的str[] = "led,100,0,80,15"，以逗号为分割，假设该字符串的第一个字符串led表示一种指令，如打开led，后面的数字表示参数，如不同led的亮度值。

那么，计算机该如何区分得到各个字符串，并且获得对应的数值型参数呢？

下面就介绍C语言中的几种函数来解决这个问题。

函数介绍与示例

strtok_r

首先需要将字符串切分为指令和参数形式，需要用到strtok_r函数。

函数定义：

1
char *strtok_r(char * __restrict__ _Str, const char * __restrict__ _Delim, char ** __restrict__ __last);
  • 参数：原始字符串，分隔符，切分后剩余的字符串
  • 返回值：切分出的字符串，若没有符合的字符串，则返回一个空指针

注意：该函数是一种破坏性操作，分割处理后原字符串 str 会被改变，变成了切分出的字符串！！！

我们将上面问题中的str作为原始字符串传入，分隔符选用逗号，切分后的保存在上面定义的paras变量中，返回值保存在上面定义的cmd变量中:

1
2
3
4
5
6
char *cmd;//表示命令
char *paras;//表示命令后的参数

cmd = strtok_r(str, ",", &paras);
printf("cmd:%s\r\n", cmd);//获得字符串的第一串字符
printf("paras:%s\r\n", paras);//获取后续字符串

查看测试结果：

1
2
cmd:led
paras:100,0,80,15

可以看到成功切分出了我们需要的命令和参数两种字符串。

strstr

对于得到参数指令字符串，我们可能还需要判断该指令是否有效，即计算机之前是否存储了该字符串，可以通过字符串匹配数组中对应字符串的方式来模拟这个测试。需要用到strstr函数，其函数定义为：

1
char *strstr(const char *_Str,const char *_SubStr);
  • 参数：原始字符串，要查找的子字符串
  • 返回值：子字符串在源字符串中首次出现的地址，无则返回NULL

我们可以先自定义一个用来查询的字符串数组funname[5]，然后依次进行匹配比较。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
char *funname[5] = {"music", "play", "A_led1", "led2", "led"};//自定义的函数名称列表

char *ret;
int i;
for (i = 0; i < 5;i++)
{
    ret = strstr(funname[i], cmd);
    if(ret!=NULL)
    {
        printf("find cmd in funname[%d]\r\n", i);
        printf("ret:%s\r\n", ret);
        break;
    }
}
if(i==5)
{
    printf("can't find cmd in funname[]");
}

测试结果：

1
2
find cmd in funname[2]
ret:led1

这里的cmd字符串是上面切分出的led，此次匹配到了A_led1中包含的led字符，因为测试代码设置了只要查找到匹配就break跳出for循环，所以没有匹配到最后那个完全相同的字符串，所以实际编程时要注意。

实际的使用中，若使用strstr这种方式来匹配字符串，可以将不同的字符串定义的差别大些，这样可以保证正确区分，测试中定义的funname只是为了演示strstr的用法。

strtok

确定了指令字符串的有效性，接下来就要切分后面的参数了，实际上我们还可以继续使用strtok_r方法，不过，我们可以使用另一个类似的函数strtok，它少一个用来保存切分后字符串的参数，其函数定义如下：

1
char *strtok(char * __restrict__ _Str,const char * __restrict__ _Delim)

  • 参数：原始字符串，分隔符

  • 返回值：切分出的字符串，若没有符合的字符串，则返回一个空指针

    注意：该函数第一次使用时，需要传入原始字符串，之后的连续使用，需要传入NULL，实际上第一次操作后，传入的原始字符串已经被改变为了第一次切分的字符串。

1
2
3
4
5
6
7
8
9
10
11
12
13
char* para[4];
para[0] = strtok(paras, ",");
int j= 1;
while(paras != NULL)
{
    para[j++] = strtok(NULL, ",");
    if(j==4)
        break;
}
printf("para[0]:%s\r\n", para[0]);
printf("para[1]:%s\r\n", para[1]);
printf("para[2]:%s\r\n", para[2]);
printf("para[3]:%s\r\n", para[3]);

运行结果：

1
2
3
4
para[0]:100
para[1]:0
para[2]:80
para[3]:15

可以看出，后面的参数也被成功分离出。

atoi

上面分离的参数数字是字符串型，实际使用时可能需要其对应的整数形式，我们可以使用atoi函数进行转换:

1
int atoi(const char *_Str);
  • 参数：数字形式的字符串
  • 返回值：对应的整形数值，若不能转换，返回0
1
2
3
4
5
6
int p1,p2,p3,p4;
p1= atoi(para[0]);
p2= atoi(para[1]);
p3= atoi(para[2]);
p4= atoi(para[3]);
printf("%d,%d,%d,%d\r\n",p1,p2,p3,p4);

测试结果：

1
100,0,80,15

%d形式的打印也正确，说明转换成功。

另外，可以测试一下atoi的其它使用情况：

1
2
3
4
//测试不能转化为数字的字符串
printf("atoi(hello): %d\r\n", atoi("hello"));
//测试浮点型字符串
printf("atoi(3.14): %d\r\n", atoi("3.14"));

输出：

1
2
atoi(hello): 0
atoi(3.14): 3

可以看出，不能转换的会返回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
80
81
82
83
84
85
86
87
88
89
90
91
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
	char *funname[5] = {"music", "play", "A_led1", "led2", "led"};//自定义的函数名称列表
	char str[] = "led,100,0,80,15";//一个字符串，第一个逗号前的字符串设定为某个命令，后面的是参数
	char *cmd;//表示命令
	char *paras;//表示命令后的参数
	printf("str=%s\r\n", str);

    //strtok_r==================================
	/*
	char *strtok_r(char * __restrict__ _Str, const char * __restrict__ _Delim, char ** __restrict__ __last);
	参数：原始字符串，分隔符，切分后剩余的字符串
	返回值：切分掉的字符串
	*/
	printf("\r\ntest [strtok_r] --------------------->\r\n");
	cmd = strtok_r(str, ",", &paras);
	printf("cmd:%s\r\n", cmd);//获得字符串的第一串字符
	printf("paras:%s\r\n", paras);//获取后续字符串
	printf("str:%s\r\n",str);//------原str已经被破坏了！！！

	//strstr=====================================
	/*
	char *strstr(const char *_Str,const char *_SubStr);
	参数：原始字符串，要查找的子字符串
	返回值：子字符串在源字符串中首次出现的地址，无则返回NULL
	*/
	printf("\r\ntest [strstr] --------------------->\r\n");
	char *ret;
	int i;
	for (i = 0; i < 5;i++)
	{
		ret = strstr(funname[i], cmd);
		if(ret!=NULL)
		{
			printf("find cmd in funname[%d]\r\n", i);
			printf("ret:%s\r\n", ret);
			break;
		}
	}
	if(i==5)
	{
		printf("can't find cmd in funname[]");
	}

	//strtok====================================
	/*
	char *strtok(char * __restrict__ _Str,const char * __restrict__ _Delim) 
	参数：原始字符串，分隔符
	返回值：切分掉的字符串
	*/
	printf("\r\ntest [strtok] --------------------->\r\n");
	char* para[4];
	para[0] = strtok(paras, ",");
	int j= 1;
	while(paras != NULL)
	{
        para[j++] = strtok(NULL, ",");
		if(j==4)
			break;
	}
	printf("para[0]:%s\r\n", para[0]);
	printf("para[1]:%s\r\n", para[1]);
	printf("para[2]:%s\r\n", para[2]);
	printf("para[3]:%s\r\n", para[3]);

    //字符串转数字================================
	/*
	int atoi(const char *_Str);
	参数：字符串
	返回值：字符串对应的数字值
	*/
	printf("\r\ntest [atoi] --------------------->\r\n");
	int p1,p2,p3,p4;
	p1= atoi(para[0]);
	p2= atoi(para[1]);
	p3= atoi(para[2]);
	p4= atoi(para[3]);
	printf("%d,%d,%d,%d\r\n",p1,p2,p3,p4);

	//测试不能转化为数字的字符串
	printf("atoi(hello): %d\r\n", atoi("hello"));

	//测试浮点型字符串
	printf("atoi(3.14): %d\r\n", atoi("3.14"));

	return 0;
}

运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
str=led,100,0,80,15

test [strtok_r] --------------------->
cmd:led
paras:100,0,80,15
str:led

test [strstr] --------------------->
find cmd in funname[2]
ret:led1

test [strtok] --------------------->
para[0]:100
para[1]:0
para[2]:80
para[3]:15

test [atoi] --------------------->
100,0,80,15
atoi(hello): 0
atoi(3.14): 3