本文提供【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属于数字十六进制表示形式中的字符(09、af、A~F);否则返回0。

#字符串子串截取
c的类库中目前没有找到现成的字符串子串截取方法。
如果是想截取指定字符串从起始位置开始的前n个字符，可以使用strncpy或memcpy代替。
但如果是想字符串截取从第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