字符串处理函数

一：查找

1：strcspn函数

该函数是标准库的函数，包含在头文件<string.h>中，其原型如下：

size_t strcspn(const char *s1, const char *s2);

该函数计算字符串s1中，从头开始的某子串的长度，该子串中的字符都不会在s2中出现。举例如下：

int main(int argc, char **argv)
{
    char *s1 = argv[1];
    char *s2 = argv[2];

    printf("the length is %d\n", strcspn(s1, s2));
}

$./1 abcdefg hij
the length is 7

$./1 defgabc hijad
the length is 0

$./1 defgabc heija
the length is 1

2：strspn函数

由strcspn函数引申，strspn的意义与其相反。它也是标准库函数，在头文件<string.h>中定义，其原型如下：

size_t strspn(const char *s1, const char *s2);

该函数计算字符串s1中，从头开始的某子串的长度，该子串中的字符都在s2中出现。举例如下：

int main(int argc, char **argv)
{
    char *s1 = argv[1];
    char *s2 = argv[2];

    printf("the length is %d\n", strspn(s1, s2));
}

$./1 abcde fgh
the length is 0

$./1 abcde fghaxzbhc
the length is 3

$./1 abcde edcbaheh
the length is 5


3：index函数

#include <strings.h>
       char * index(const char *string, int c);

该函数等价于strchr函数，返回一个指针，该指针指向字符串string中，字符c第一次出现的位置，如果字符c未出现在string中，则返回NULL，举例如下：

int main(int argc, char **argv)
{
    char *s1 = argv[1];
    int c = argv[2][0];

    char *res1 = index(s1, c);
    char *res2 = strchr(s1, c);

    printf("res1 is %p\n", res1);
    printf("res2 is %p\n", res2);
}

$./1 abcdef h
res1 is 0x0
res2 is 0x0

$./1 abcdef a
res1 is 0x612f2d44
res2 is 0x612f2d44

$./1 abcdef c
res1 is 0x612f2d46
res2 is 0x612f2d46


4：strpbrk函数

strpbrk是标准库函数，在头文件<string.h>中定义，其原型如下：

char *strpbrk(const char *s, const char *accept);

该函数在字符串s中，寻找accept字符串中任意字符的首次出现的位置。如果找到了任意字符，则返回指向该字符的指针，如果没找到，则返回NULL。
该函数是线程安全的。例子如下：

int main(int argc, char **argv)
{
    if(argc != 3)
    {
        printf("argument error\n");
        return -1;
    }

    char *str = argv[1];
    char *accept = argv[2];

    char *res = strpbrk(str, accept);
    if(res == NULL)
    {
        printf("NULL\n");
    }
    else
    {
        printf("res is %s\n", res);
    }
}

$ ./1 "//abc/def/hehe/abc:/abc:def//" ""

NULL

$./1 "//abc/def/hehe/abc:/abc:def//" ":/"
res is //abc/def/hehe/abc:/abc:def//

$./1 "//abc/def/hehe/abc:/abc:def//" ":"
res is :/abc:def//

$./1 "//abc/def/hehe/abc:/abc:def//" "a"
res is abc/def/hehe/abc:/abc:def//

$./1 "//abc/def/hehe/abc:/abc:def//" "h"
res is hehe/abc:/abc:def//

$./1 "//abc/def/hehe/abc:/abc:def//" "z"
NULL


二：分割

1：strtok和strtok_r函数

strtok函数是标准库函数，包含在头文件 <string.h>中，其原型如下：

char *strtok(char *str, const char *delim);

strtok函数用来将一字符串分割为一系列的子串。要得到原字符串被分割后的所有子串，需要多次调用strtok，每次调用都返回一个子串的首地址。第一次调用strtok时，str需要指向分割的字符串，但在后续的调用中，置str为NULL即可。

delim参数指向的字符串包含了若干分割字符。在分割同一个字符串时，可以在delim中指定不同的分隔字符。

strtok返回一个指向子串的指针，该子串以’\0’结尾。该子串不会包含分隔符。如果已经没有子串了，则该函数返回NULL。



在strtok函数的实现中，内部使用一静态指针old，该指针保存的是每次搜索子串的起始地址。第一次调用strtok时，该指针就是原字符串的首字符。

本次调用strtok要寻找的子串首地址，由str中的下一个非分隔字符决定。如果找到了这样的字符，则它就是本次子串的首字符。如果没有找到这样的子串，则strtok返回NULL。

子串的结尾，由下一个分隔字符或者’\0’决定。如果找到了一个分隔字符，则该位置被置为’\0’，并且将old指向下一个字符。

根据上面的描述，可知，两个或多个连续的分割字符会被当做一个分隔符，并且会忽略原字符串中起始字符或者结尾字符是分隔字符的情况。因此strtok返回的子串一定不会是空串。在最新的GLIBC2.22版本中，strtok的源码如下：

static char *olds;

char *strtok (char *s, const char *delim)
{
    char *token;
    if (s == NULL)
        s = olds;

    /* Scan leading delimiters.  */
    s += strspn (s, delim);
    if (*s == '\0')
    {
      olds = s;
      return NULL;
    }

    /* Find the end of the token.  */
    token = s;
    s = strpbrk (token, delim);
    if (s == NULL)
        /* This token finishes the string.  */
        olds = __rawmemchr (token, '\0');
    else
    {
        /* Terminate the token and make OLDS point past it.  */
        *s = '\0';
        olds = s + 1;
    }
    return token;
}

因strtok函数内部使用了静态指针，因此它不是线程安全的。相应的线程安全函数是strtok_r，它是strtok函数的可重入版本。它的原型如下：

char *strtok_r(char *str, const char *delim, char **saveptr);

其中的saveptr参数，便充当了strtok中old指针的角色，strtok_r的代码与strtok基本一样，只不过其中的old都替换成了*saveptr。



注意：这些函数会改变原字符串的内容，所以，第一个参数不能是只读的。例子如下：

int main(int argc, char **argv)
{
    if(argc != 3)
    {
        printf("argument error\n");
        return -1;
    }
    
    char *delim = argv[2];

    int strsize = strlen(argv[1])+1;
    char *str = calloc(strsize, sizeof(char));
    memcpy(str, argv[1], strsize-1);
    char *token = NULL;
    char *tmpstr = str;

    while((token = strtok(tmpstr, delim)) != NULL)
    {
        printf("\t%s\n", token);
        tmpstr = NULL;
    }

    int i = 0;
    for(i = 0; i < strsize; i++)
    {
        printf("%c ", str[i]);
    }
    printf("\n");
}

$ ./1 "//abc/def/hehe/abc:/abc:def//" ""
        //abc/def/hehe/abc:/abc:def//
/ / a b c / d e f / h e h e / a b c : / a b c : d e f / /

$ ./1  "//abc/def/hehe/abc:/abc:def//" ":/"
        abc
        def
        hehe
        abc
        abc
        def
/ / a b c  d e f  h e h e  a b c  / a b c  d e f  /

2：strsep函数

strsep函数包含在头文件<string.h>中，其原型如下：

char *strsep(char **stringp, const char *delim);

strsep函数与strtok函数的功能一样，也是用来分割字符串的。但是它们又有几处明显的不同：

a：如果*stringp为NULL，则该函数不进行任何操作，直接返回NULL；

b：strsep每次都是从*stringp指向的位置开始搜索，搜索到任一分割字符之后，将其置为’\0’，并使*stringp指向它的下一个字符。如果找不到任何分割字符，则将*stringp置为NULL。

c：strsep内部没有使用静态指针，因而strsep是线程安全的。

d：strsep返回的子串有可能是空字符串，实际上，就是因为strtok无法返回空子串，才引入的strsep函数。不过strtok符合C89/C99标准，因而移植性更好。但strsep却不是。



在最新的GLIBC2.22版本中，strsep的源码如下：

char *strsep (char **stringp, const char *delim)
{
    char *begin, *end;

    begin = *stringp;
    if (begin == NULL)
        return NULL;

    /* A frequent case is when the delimiter string contains only one
     character.  Here we don't need to call the expensive `strpbrk'
     function and instead work using `strchr'.  */
    if (delim[0] == '\0' || delim[1] == '\0')
    {
        char ch = delim[0];

        if (ch == '\0')
            end = NULL;
        else
        {
            if (*begin == ch)
                end = begin;
            else if (*begin == '\0')
                end = NULL;
            else
                end = strchr (begin + 1, ch);
        }
    }
    else
        /* Find the end of the token.  */
        end = strpbrk (begin, delim);

    if (end)
    {
        /* Terminate the token and set *STRINGP past NUL character.  */
        *end++ = '\0';
        *stringp = end;
    }
    else
        /* No more delimiters; this is the last token.  */
        *stringp = NULL;

    return begin;
}

例子如下：

int main(int argc, char **argv)
{
    if(argc != 3)
    {
        printf("argument error\n");
        return -1;
    }
    
    char *delim = argv[2];

    int strsize = strlen(argv[1])+1;
    char *str = calloc(strsize, sizeof(char));
    memcpy(str, argv[1], strsize-1);
    char *token = NULL;
    char *tmpstr = str;

    while((token = strsep(&tmpstr, delim)) != NULL)
    {
        printf("\t%s\n", token);
    }

    int i = 0;
    for(i = 0; i < strsize; i++)
    {
        printf("%c ", str[i]);
    }
    printf("\n");
}

$ ./1 "//abc/def/hehe/abc:/abc:def//" ""
token is:  //abc/def/hehe/abc:/abc:def//
/ / a b c / d e f / h e h e / a b c : / a b c : d e f / /

$ ./1 "//abc/def/hehe/abc:/abc:def//" "/"
token is:
token is:
token is:  abc
token is:  def
token is:  hehe
token is:  abc:
token is:  abc:def
token is:
token is:
  a b c  d e f  h e h e  a b c :  a b c : d e f

$ ./1 "//abc/def/hehe/abc:/abc:def//" ":/"
token is:
token is:
token is:  abc
token is:  def
token is:  hehe
token is:  abc
token is:
token is:  abc
token is:  def
token is:
token is:
  a b c  d e f  h e h e  a b c   a b c  d e f