本文提供【C/C++】string操作方法汇总如下:

  • 判断内容是否相同
  • 字符串复制
  • 字符串拼接
  • 字符串拼接单个char
  • 字符串类别检查
  • 字符串子串截取 (substring)
  • 字符串界位符切割 (strtok strtok_r)

#判断内容是否相同

#include <string.h>

  • int strcmp(const char *s1, const char *s2); Thread-Safe
    int strncmp(const char *s1, const char *s2, size_t n); Thread-Safe
    对s1与s2进行的比较。大小写敏感。
    return ==0, s1 == s2;
    return >0, s1 > s2;
    return <0, s1 < s2;

  • int memcmp(const void *s1, const void *s2, size_t n); Thread-safe
    注意,这里的参数是void而不是普通的char *,所以memcmp可以对更广泛的对象进行对比,如字符数组,整型,类,结构体等。比较的内容为第三个参数所限定的长度范围内。

  • int strcoll(const char *s1, const char *s2);
    比较字符串s1和s2。功能和strcmp类似,用法也一样.
    特别注意:strcoll()会依环境变量LC_COLLATE所指定的文字排列次序来比较s1和s2字符串。
    strcmp是根据ASCII来比较2个字符串的.若LC_COLLATE为”POSIX”或”C”,则strcoll()与strcmp()作用完全相同。

#include <strings.h>

  • int strcasecmp(const char *s1, const char *s2);
    int strncasecmp(const char *s1, const char *s2, size_t n);
    对s1与s2进行大小写无关的比较。
    return ==0, s1 == s2;
    return >0, s1 > s2;
    return <0, s1 < s2;

  • int bcmp(const void *s1, const void *s2, size_t n) Thread-Safe
    已废弃的方法,不推荐使用。推荐使用memcmp代替。

#字符串复制
#include <string.h>

  • char *strcpy(char *dest, const char *src); Thread-Safe
    char *strncpy(char *dest, const char *src, size_t n); Thread-Safe
    将src指向的字符串(全部或指定的n个字符)复制到dest中,其中dest与src指向的内存空间不能重叠。要保证dest有足够的空间能够容纳src中的内容,否则may make the impossible possible.
    对于strncpy()只负责拷贝指定长度的字符,拷贝完并不会在字符的结尾加上字符串终止符。所以见下面的示例代码中会打印出”c.st strcpy()”.对于n其长度最大值就为dest_length -1,因为最后一个位置还要放一个字符串终止符。
1
2
3
4
5
6
char * strA = "Test strcpy()"; // 对于下面的strDest中长度最小要13 + 1=14。
char strDest[100]; // 声明一个数组,空间对于将要复制的字符串来说要足够大。
char *strcpy = strcpy(strDest, strA); // 执行复制。
printf("%s \n", strcpy); // 打印出:Test strcpy()
strcpy = strncpy(strDest, "c.code", 2); // 执行指定长度的字符串内容。
printf("%s \n", strcpy); // 打印出:c.st strcpy()

strncpy()如果src比较小,而指定的n比较大时,则strncpy会把多出来的长度用/0填充,这就引出一个效率上不高的问题:如下面的代码中strncpy会填写99个char,而不止是”ab”本身。

1
2
char strDest[100];
strncpy(strDest, "ab", 99);

  • void *memcpy(void *dest, const void *src, size_t n);
    用法同strncpy(),但注意到这是纯内存拷贝操作,可以对更广泛的对象进行对比,如字符数组,整型,类,结构体等。

  • size_t strlcpy(char * restrict dst, const char * restrict src, size_t size);
    strlcpy()是为替代strncpy()而实现的更简易、更安全、更不容易出错的字符串拷贝方式。
    使用时仅需如下例子在size参数中传入sizeof(dst)即可不用考虑执行结果中是否包含字符串终止符的问题(自动给加上了)。
    strlcpy()仅仅会从src中拷贝最多size -1个字符,并在dest最后添加上字符串终止符。
    strlcpy()的返回值是src的长度,所以一旦结果为len > sizeof(buf),则表示拷贝的结果把src截断了。

    1
    2
    3
    4
    5
    char *src, *p, buf[BUFSIZ];
    int len = strlcpy(buf, src, sizeof(buf));
    if (len > sizeof(buf)){
    printf("%s \n", "string src is truncated.");

#字符串拼接
#include <string.h>

  • char *strcat(char *dest, const char *src); Thread-Safe
    char *strncat(char *dest, const char *src, size_t n); Thread-Safe
    string concatenate
    字符串拼接同上面的复制,都要求dest有足够的空间,且dest和src所指向的空间不能重叠。
    dest的空间长度最小值为 strlen(dest) + n + 1。其中n表示strlen(src)或指定要拼接的长度值n,最后一个1表示字符串终止符。

    1
    2
    3
    4
    5
    6
    7
    // 声明一个数组,空间对于将要复制和拼接的字符串来说要足够大。
    // 6是最小值, 6 = strlen(strA) + 2(strcat) + 1(\0)
    char strDest[6];
    char * strA = "abc";
    strcpy(strDest, strA);
    strncat(strDest, "123", 2);
    printf("%s \n", strDest); // 打印出:abc12
  • size_t strlcat(char * restrict dst, const char * restrict src, size_t size);
    同strlcpy(),是保证进行字符串拼接时以字符串终止符结尾。第三个参数size应传入dst的长度。
    在如下代码中,很明显dest的空间是不足以拼接”123456789”的,所以最后的拼接结果是“12345”+1个字符串终止符。

    1
    2
    3
    4
    5
    6
    7
    char strDest[6];
    char * strA = "123456789";
    int result = strlcat(strDest, strA, sizeof(strDest));
    printf("%s\n", strDest); // 打印出“12345”
    if (result){
    printf("%s be truncated.\n", strA);
    }

#字符串拼接单个char
c中没有现成的函数可以拼接单个char,这里需要用到指针进行赋值,如下:

1
2
3
4
5
6
7
8
9
10
11
12
char dest[5];
char *str = "abc";
// 对dest赋值
strcpy(dest, str);
char * pDest;
pDest = dest + strlen(dest);
// 拼接单个字符串
*pDest++ = '1';
*pDest++ = 0; // 字符串终止符
// 打印出:abc1 5 4
printf("%s %lu %lu \n", dest, sizeof(dest), strlen(dest));

#字符串长度
之所以把字符串长度放在字符串拼接之后,是为了更方便讲述理解。
#include <string.h>

  • size_t strlen(const char *s);
    strlen()直接计算参数s中字符的个数,直至碰到字符串终止符\0时停止计算。所以在字符串拼接单个char中,strlen(dest)返回结果是4。
    但如果把代码稍作修改成如下,则strlen(dest)返回的结果可就不一定了。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    char dest[5];
    char *str = "abc";
    // 对dest赋值
    strcpy(dest, str);
    char * pDest;
    pDest = dest + strlen(dest);
    // 拼接单个字符串
    *pDest++ = '1';
    *pDest++ = '2'; // 改动点:不以字符串终止符结尾
    // 打印出:abc12\300\370\277_\377 5 11 内容是不固定的
    printf("%s %lu %lu \n", dest, sizeof(dest), strlen(dest));

可以看到,strlen()返回的长度已经超出了dest可容纳的最大值。所以该函数返回的结果存在一定的溢出风险。
如何解决该问题?可以使用下面的函数。

  • size_t strnlen(const char *s, size_t maxlen);
    strnlen()的第2个参数指定s的最大值,正常情况下和strlen()能力是一致的。区别在于strnlen()返回的最大值最多只能是maxlen。所以如果返回值为参数maxlen时,即可以判断出s是非正常的字符串终止符结尾,需要特别处理。见下示例代码。
    1
    2
    3
    4
    5
    6
    int n_len = strnlen(dest, sizeof(dest));
    if (n_len >= sizeof(dest)){
    printf("dest is not NUL-TERMINALED \n");
    } else {
    printf("dest.len=%d \n", n_len);
    }

#字符类别检查
#include <ctype.h>

  • int isalnum(int c);
    返回1表示字符c是 大小写字母 或 数字;否则返回0。
  • int isalpha(int c);
    返回1表示字符c是 大小写字母 ;否则返回0。
    相当于(isupper(c) || islower(c))。在某些locale设置下,有可能一些非字母字符也返回1。
  • int isascii(int c);
    返回1表示字符c属于 ASCII字符集 ;否则返回0。
  • int isblank(int c);
    返回1表示字符c是 空格 或 Tab符\t;否则返回0。注意有些系统或编辑器下的Tab符是由多个空格组成的,这种情况下返回0。
  • int iscntrl(int c);
    返回1表示字符c是控制制服(c:[0:31…]等等)
  • int isdigit(int c);
    返回1表示字符c属于0~9的数字;否则返回0。
  • int isgraph(int c);
    返回1表示字符c属于印刷可见的字符(不包含空格);否则返回0。大部分情况下返回结果和iscntrl(c)是相反的。
  • int islower(int c);
    返回1表示是英文字母中的小写字符;否则返回0。
  • int isprint(int c);
    同isgraph(c),区别在于c是空格时也返回1。
  • int ispunct(int c);
    返回1表示排除了空格及英文字母数字的可打印字符集;否则返回0。
  • int isspace(int c);
    返回1时表示c属于 空格、\f、换行符‘\n’、回车’\r’、水平Tab\t、垂直Tab\v;否则返回0。
  • int isupper(int c);
    返回1时表示c羽毛球英文字母中的大写字母。
  • int isxdigit(int c);
    返回1时表示c属于数字十六进制表示形式中的字符(0~9、a~f、A~F);否则返回0。

#字符串子串截取
c的类库中目前没有找到现成的字符串子串截取方法。
如果是想截取指定字符串从起始位置开始的前n个字符,可以使用strncpymemcpy代替。
但如果是想字符串截取从第n个到第n+x个字符的子字符串,得自己实现了。示例代码如下:

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
static
char* substring(const char* src, const int idxStart, const int idxEnd) {
if (strlen(src) == 0) {
printf("arg src.length is 0, return.");
return (void*)0;
}
if (idxEnd > strlen(src)) {
printf("idxEnd=%d > strlen(src)=%lu, return.", idxEnd, strlen(src));
return (void*)0;
}
if (idxStart >= idxEnd) {
printf("idxStart=%d >= idxEnd=%d, return.", idxStart, idxEnd);
return (void*)0;
}
// 避免直接定义固定长度
int length = idxEnd - idxStart + 1;
const int sub_length = length;
// 使用malloc,避免在函数体结束之后即回回收导致函数返回值无法被使用。
// 需要使用free()释放;
char * pDest = (char*)malloc(sub_length);
for (int i = idxStart;i < idxEnd;i ++) {
// printf("src %c \n", *(src+i));
*(pDest + (i-idxStart)) = *(src+i);
// printf("dest %c \n", *(pDest + (i-idxStart)));
}
*(pDest+(idxEnd - idxStart)) = 0; // 添加上字符串终止符
// printf("pDest=%s %p\n", pDest, pDest);
return pDest;
}
int main(int argc, const char * argv[]) {
char * src = "abc123ABC";
char *dest = substring(src, 3, 6);
//打印出"123"
printf("substring1=[%s] \n", dest);
// 不要了,回收掉
free(dest);
// 不需要了之后对指针置空,防止野指针
dest = NULL;
printf("%s \n", dest);
}

#字符串界位符切割
#include <string.h>

  • char *strtok(char *str, const char *delim);
  • char *strtok_r(char *str, const char \delim, char \*saveptr);
    以上两个函数可以将指定的字符串切割成0个或数个非空子串.
    以上两个函数在第一次调用时,第一个参数str传入待切割的长字符串;在下次循环调用之前需要把str置为NULL。
    第2个参数delim指定切割关键字符集(所以可以包含多种情况)。
    函数执行后的返回结果是切割后的子字符串,如果返回为NULL,则表示已经没有目标切割对象了,可以停止循环。
    以下代码示例strtok()的使用,切割标准为-:字符:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    char * token;
    char original[] = "ab-cd;ef-gh";
    char * src = original;
    char * delim = ";-";
    for(int i = 0;; i ++) {
    token = strtok(src, delim);
    if (token == NULL){
    break;
    }
    printf("%d:%s ", i, token);
    if (src != NULL) {
    src = NULL; // 对src置空
    }
    }
    // 打印出:0:ab 1:cd 2:ef 3:gh

对src置空后,循环的调用仍可输出切割的子字符串结果,个人觉得应该是在strtok()方法体内使用了函数内静态参数的原因。

strtok_r():strtok reentrant
strtok_r()是可重入版本的strtok()方法。第三个参数saveptr用于指向未进行切割处理的字符串子串。是指向指针的指针。这也是可重入计算的关键。
如下示例代码中演示了strtok_r()的可重入计算,即在循环体内再嵌套一个循环用第二种界位符对字符进行二次切割。

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
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
int main(int argc, const char * argv[]) {
char *str1, *str2, *token, *subtoken;
char *saveptr1, *saveptr2;
int j;
if (argc != 4) {
fprintf(stderr, "Usage: %s string delim subdelim\n", argv[0]);
exit(EXIT_FAILURE);
}
const unsigned long argv1_len = strlen(argv[1]);
char argv1[argv1_len];
strcpy(argv1, argv[1]);
printf("argv1=%s \n", argv1);
// for (j = 1, str1 = argv[1]; ; j++, str1 = NULL) {
// 这种写法,避免Assigning to 'char *' from 'const char *' discards qualifiers
for (j = 1, str1 = argv1; ; j++, str1 = NULL) {
token = strtok_r(str1, argv[2], &saveptr1);
if (token == NULL)
break;
printf("%d: %s %s\n", j, token, saveptr1);// 当saveptr1为null时,则下个循环时strtok_r()返回结果亦为null
for (str2 = token; ; str2 = NULL) {
subtoken = strtok_r(str2, argv[3], &saveptr2);
if (subtoken == NULL)
break;
printf(" --> %s \n", subtoken);
}
}
exit(EXIT_SUCCESS);
}

在命令行工具下执行命令,对长字符进行两次切割,先”-:”后”/“。
运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
sodino:CString sodino$ ./a.out "a-b-cd:ef/hi/jk:///lm://no-p:q" "-:" "/"
argv1=a-b-cd:ef/hi/jk:///lm://no-p:q
1: a b-cd:ef/hi/jk:///lm://no-p:q
--> a
2: b cd:ef/hi/jk:///lm://no-p:q
--> b
3: cd ef/hi/jk:///lm://no-p:q
--> cd
4: ef/hi/jk ///lm://no-p:q
--> ef
--> hi
--> jk
5: ///lm //no-p:q
--> lm
6: //no p:q
--> no
7: p q
--> p
8: q (null)
--> q