c语言字符串操作函数

1、初始化字符串

1. #include <string.h>   
2. void *memset(void *s, int c, size_t n);   
3. //返回值：s指向哪，返回的指针就指向哪   

memset函数把s所指的内存地址开始的n个字节都填充为c的值。通常c的值为0，把一块内存区清零。例如定义char buf[10];，如果它是全局变量或静态变量，则自动初始化为0（位于.bss段），如果它是函数的局部变量，则初值不确定，可以用memset(buf, 0, 10)清零，由malloc分配的内存初值也是不确定的，也可以用memset清零。

2、取字符串的长度

1. #include <string.h>   
2. size_t strlen(const char *s);   
3. //返回值：字符串的长度  

strlen函数返回s所指的字符串的长度。该函数从s所指的第一个字符开始找'\0'字符，一旦找到就返回，返回的长度不包括'\0'字符在内。例如定义char buf[] = "hello";，则strlen(buf)的值是5，但要注意，如果定义char buf[5] = "hello";，则调用strlen(buf)是危险的，会造成数组访问越界。

3、拷贝字符串

1. #include <string.h>   
2. void *memcpy(void *dest, const void *src, size_t n);   
3. void *memmove(void *dest, const void *src, size_t n);   
4. //返回值：dest指向哪，返回的指针就指向哪  

memcpy函数从src所指的内存地址拷贝n个字节到dest所指的内存地址，和strncpy不同，memcpy并不是遇到'\0'就结束，而是一定会拷贝完n个字节。这里的命名规律是，以str开头的函数处理以'\0'结尾的字符串，而以mem开头的函数则不关心'\0'字符，或者说这些函数并不把参数当字符串看待，因此参数的指针类型是void *而非char *。

memmove也是从src所指的内存地址拷贝n个字节到dest所指的内存地址，虽然叫move但其实也是拷贝而非移动。但是和memcpy有一点不同，memcpy的两个参数src和dest所指的内存区间如果重叠则无法保证正确拷贝，而memmove却可以正确拷贝。假设定义了一个数组char buf[20] = "hello world\n";，如果想把其中的字符串往后移动一个字节（变成"hhello world\n"），调用memcpy(buf + 1, buf, 13)是无法保证正确拷贝的：

例 3.1错误的memcpy调用

1. #include <stdio.h>   
2. #include <string.h>   
3.   
4. int main(void)   
5. {   
6.     char buf[20] = "hello world\n";   
7.     memcpy(buf + 1, buf, 13);   
8.     printf(buf);   
9.   
10.     return 0;   
11. }
    

在我的机器上运行的结果是hhhllooworrd。如果把代码中的memcpy改成memmove则可以保证正确拷贝。memmove可以这样实现：

1. void *memmove(void *dest, const void *src, size_t n)   
2. {   
3.     char temp[n];   
4.     int i;   
5.     char *d = dest;   
6.     const char *s = src;   
7.   
8.     for (i = 0; i < n; i++)   
9.         temp[i] = s[i];   
10.     for (i = 0; i < n; i++)   
11.         d[i] = temp[i];   
12.   
13.     return dest;   
14. }  

借助于一个临时缓冲区temp，即使src和dest所指的内存区间有重叠也能正确拷贝。

4、连接字符串

1. #include <string.h>   
2. char *strcat(char *dest, const char *src);   
3. char *strncat(char *dest, const char *src, size_t n);   
4. //返回值：dest指向哪，返回的指针就指向哪  

strcat把src所指的字符串连接到dest所指的字符串后面，例如：

1. char d[10] = "foo";   
2. char s[10] = "bar";   
3. strcat(d, s);   
4. printf("%s %s\n", d, s);  

调用strcat函数后，缓冲区s的内容没变，缓冲区d中保存着字符串"foobar"，注意原来"foo"后面的'\0'被连接上来的字符串"bar"覆盖掉了，"bar"后面的'\0'仍保留。

strcat和strcpy有同样的问题，调用者必须确保dest缓冲区足够大，否则会导致缓冲区溢出错误。strncat函数通过参数n指定一个长度，就可以避免缓冲区溢出错误。注意这个参数n的含义和strncpy的参数n不同，它并不是缓冲区dest的长度，而是表示最多从src缓冲区中取n个字符（不包括结尾的'\0'）连接到dest后面。如果src中前n个字符没有出现'\0'，则取前n个字符再加一个'\0'连接到dest后面，所以strncat总是保证dest缓冲区以'\0'结尾，这一点又和strncpy不同，strncpy并不保证dest缓冲区以'\0'结尾。所以，提供给strncat函数的dest缓冲区的大小至少应该是strlen(dest)+n+1个字节，才能保证不溢出。

5、比较字符串

1. #include <string.h>   
2. int memcmp(const void *s1, const void *s2, size_t n);   
3. int strcmp(const char *s1, const char *s2);   
4. int strncmp(const char *s1, const char *s2, size_t n);   
5. //返回值：负值表示s1小于s2，0表示s1等于s2，正值表示s1大于s2  

memcmp从前到后逐个比较缓冲区s1和s2的前n个字节（不管里面有没有'\0'），如果s1和s2的前n个字节全都一样就返回0，如果遇到不一样的字节，s1的字节比s2小就返回负值，s1的字节比s2大就返回正值。

strcmp把s1和s2当字符串比较，在其中一个字符串中遇到'\0'时结束，按照上面的比较准则，"ABC"比"abc"小，"ABCD"比"ABC"大，"123A9"比"123B2"小。

strncmp的比较结束条件是：要么在其中一个字符串中遇到'\0'结束（类似于strcmp），要么比较完n个字符结束（类似于memcmp）。例如，strncmp("ABCD", "ABC", 3)的返回值是0，strncmp("ABCD", "ABC", 4)的返回值是正值。

1. #include <strings.h>   
2. int strcasecmp(const char *s1, const char *s2);   
3. int strncasecmp(const char *s1, const char *s2, size_t n);   
4. //返回值：负值表示s1小于s2，0表示s1等于s2，正值表示s1大于s2  

这两个函数和strcmp/strncmp类似，但在比较过程中忽略大小写，大写字母A和小写字母a认为是相等的。这两个函数不属于C标准库，是POSIX标准中定义的。

6、搜索字符串

1. #include <string.h>   
2. char *strchr(const char *s, int c);   
3. char *strrchr(const char *s, int c);   
4. //返回值：如果找到字符c，返回字符串s中指向字符c的指针，如果找不到就返回NULL  

strchr在字符串s中从前到后查找字符c，找到字符c第一次出现的位置时就返回，返回值指向这个位置，如果找不到字符c就返回NULL。strrchr和strchr类似，但是从右向左找字符c，找到字符c第一次出现的位置就返回，函数名中间多了一个字母r可以理解为Right-to-left。

1. #include <string.h>   
2. char *strstr(const char *haystack, const char *needle);   
3. //返回值：如果找到子串，返回值指向子串的开头，如果找不到就返回NULL  

strstr在一个长字符串中从前到后找一个子串（Substring），找到子串第一次出现的位置就返回，返回值指向子串的开头，如果找不到就返回NULL。这两个参数名很形象，在干草堆haystack中找一根针needle，按中文的说法叫大海捞针，显然haystack是长字符串，needle是要找的子串。

7、分割字符串

很多文件格式或协议格式中会规定一些分隔符或者叫界定符（Delimiter），例如/etc/passwd文件中保存着系统的帐号信息：

1. $ cat /etc/passwd   
2. root:x:0:0:root:/root:/bin/bash   
3. daemon:x:1:1:daemon:/usr/sbin:/bin/sh   
4. bin:x:2:2:bin:/bin:/bin/sh   
5. ...  

每条记录占一行，也就是说记录之间的分隔符是换行符，每条记录又由若干个字段组成，这些字段包括用户名、密码、用户id、组id、个人信息、主目录、登录Shell，字段之间的分隔符是:号。解析这样的字符串需要根据分隔符把字符串分割成几段，C标准库提供的strtok函数可以很方便地完成分割字符串的操作。tok是Token的缩写，分割出来的每一段字符串称为一个Token。

1. #include <string.h>   
2. char *strtok(char *str, const char *delim);   
3. char *strtok_r(char *str, const char *delim, char **saveptr);   
4. //返回值：返回指向下一个Token的指针，如果没有下一个Token了就返回NULL  

参数str是待分割的字符串，delim是分隔符，可以指定一个或多个分隔符，strtok遇到其中任何一个分隔符就会分割字符串。看下面的例子。

例 7.1. strtok

1. #include <stdio.h>   
2. #include <string.h>   
3.   
4. int main(void)   
5. {   
6.     char str[] = "root:x::0:root:/root:/bin/bash:";   
7.     char *token;   
8.     token = strtok(str, ":");   
9.     printf("%s\n", token);   
10.     while ( (token = strtok(NULL, ":")) != NULL)   
11.     printf("%s\n", token);   
12.   
13.     return 0;   
14. }  

 

1. $ ./a.out   
2. root   
3. x   
4. 0   
5. root   
6. /root   
7. /bin/bash  

结合这个例子，strtok的行为可以这样理解：冒号是分隔符，把"root:x::0:root:/root:/bin/bash:"这个字符串分隔成"root"、"x"、""、"0"、"root"、"/root"、"/bin/bash"、""等几个Token，但空字符串的Token被忽略。第一次调用要把字符串首地址传给strtok的第一个参数，以后每次调用第一个参数只要传NULL就可以了，strtok函数自己会记住上次处理到字符串的什么位置（显然这是通过strtok函数中的一个静态指针变量记住的）。

函数名: strrchr 
功  能: 在串中查找指定字符的最后一个出现 
用  法: char *strrchr(char *str, char c);

举例：

[cpp]  view plain copy

1. char fullname="./lib/lib1.so";  
2. char *ptr;  
3. ptr = strrchr(fullname,'/');  
4. printf("filename is %s",++ptr);  
5. //运行结果：filename is lib1.so  

 函数名: strchr 

功  能: 在串中查找指定字符的第一个出现 
用  法: char *strchr(char *str, char c);

举例：

[cpp]  view plain copy

1. char fullname="./lib/lib1.so";  
2. char *ptr;  
3. ptr = strrchr(fullname,'.');  
4. printf("after strchr() is %s",++ptr);  
5. //运行结果：after strchr() is  /lib/lib1.so  

 函数名: strtok 

功  能: 在串中查找指定字符的第一个出现 
用  法: char *strtok(char *s, char *delim);

说明：

1.strtok函数的实质上的处理是，strtok在s中查找包含在delim中的字符并用NULL(’/0′)来替换,直到找遍整个字符串。这句话有两层含义：（1）每次调用strtok函数只能获得一个分割单位。（2）要获得所有的分割单元必须反复调用strtok函数。

2.strtok函数以后的调用时的需用NULL来替换s.

3.形参s(要分割的字符串)对应的变量应用char s[]=”….”形式，而不能用char *s=”….”形式。

举例：

[cpp]  view plain copy

1. void  main()   
2. {   
3.     char buf[]=”Golden Global View”;   
4.     char* token = strtok( buf, ” “);   
5.     while( token != NULL )   
6.     {   
7.         printf( ”%s “, token );    
8.         token = strtok( NULL, ” “);   
9.     }   
10.     return 0;   
11. }   
12. /*其结果为： 
13.  
14. Golden 
15. Global 
16. View 
17. */  

 函数名：strncpy

功能：把src所指由NULL结束的字符串的前n个字节复制到dest所指的数组中

用法：char *strncpy(char *dest, char *src, int n);

说明：    

        如果src的前n个字节不含NULL字符，则结果不会以NULL字符结束。
        如果src的长度小于n个字节，则以NULL填充dest直到复制完n个字节。
        src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
        返回指向dest的指针。

举例：

[c-sharp]  view plain copy

1.   #include <syslib.h>  
2.       #include <string.h>  
3.   
4.       main()  
5.       {  
6.         char buf[4];  
7.         char *s="abcdefg";  
8.          
9.         strncpy(buf,s,4);  
10.         printf("%s/n",buf);  
11.         return 0;  
12.       }  
13. /*运行结果： 
14. abcd 
15. */  

 函数名: stpcpy

功  能: 拷贝一个字符串到另一个
用  法: char *stpcpy(char *destin, char *source);

举例：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <string.h>  
3. int main(void)  
4. {  
5.    char string[10];  
6.    char *str1 = "abcdefghi";  
7.    stpcpy(string, str1);  
8.    printf("%s/n", string);  
9.    return 0;  
10. }  
11. /*运行结果 
12. abcdefghi 
13. */  

 函数名: strcat

功  能: 字符串拼接函数
用  法: char *strcat(char *destin, char *source);
举例：

[cpp]  view plain copy

1. #include <string.h>  
2. #include <stdio.h>  
3. int main(void)  
4. {  
5.    char destination[25];  
6.    char *blank = " ", *c = "C++", *Borland = "Borland";  
7.    strcpy(destination, Borland);  
8.    strcat(destination, blank);  
9.    strcat(destination, c);  
10.    printf("%s/n", destination);  
11.    return 0;  
12. }  
13. /*运行结果： 
14. Borland C++ 
15. */  

 函数名: strcmp

功  能: 串比较
用  法: int strcmp(char *str1, char *str2);
看Asic码，str1>str2，返回值 > 0；两串相等，返回0

举例：

[cpp]  view plain copy

1. #include <string.h>  
2. #include <stdio.h>  
3. int main(void)  
4. {  
5.     char *buf1 = "aaa", *buf2 = "bbb"；  
6.     int ptr;  
7.     ptr = strcmp(buf2, buf1);  
8.     if (ptr > 0)  
9.        printf("buffer 2 is greater than buffer 1/n");  
10.     else if(ptr < 0)  
11.        printf("buffer 2 is less than buffer 1/n");  
12.     else  
13.        printf("buffer 2 is equal with buffer 1/n");  
14.     return 0;  
15. }  
16. /*运行结果： 
17. buffer 2 is greater than buffer 1 
18. */  

 函数名: strncmpi

功  能: 将一个串中的一部分与另一个串比较, 不管大小写
用  法: int strncmpi(char *str1, char *str2, unsigned maxlen);

举例：

[cpp]  view plain copy

1. #include <string.h>  
2. #include <stdio.h>  
3. int main(void)  
4. {  
5.    char *buf1 = "BBB", *buf2 = "bbb";  
6.    int ptr;  
7.    ptr = strcmpi(buf2, buf1);  
8.    if (ptr > 0)  
9.       printf("buffer 2 is greater than buffer 1/n");  
10.    if (ptr < 0)  
11.       printf("buffer 2 is less than buffer 1/n");  
12.    if (ptr == 0)  
13.       printf("buffer 2 equals buffer 1/n");  
14.    return 0;  
15. }  

 函数名: strcspn

功  能: 在串中查找第一个给定字符集内容的段
用  法: int strcspn(char *str1, char *str2);
举例：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <string.h>  
3. #include <alloc.h>  
4. int main(void)  
5. {  
6.     char *string1 = "1234567890";  
7.     char *string2 = "747DC8";  
8.     int length;  
9.     length = strcspn(string1, string2);  
10.     printf("Character where strings intersect is at position %d/n", length);  
11.     return 0;  
12. }  

 函数名: strdup

功  能: 将串拷贝到新建的位置处
用  法: char *strdup(char *str);
举例：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <string.h>  
3. #include <alloc.h>  
4. int main(void)  
5. {  
6.     char *dup_str, *string = "abcde";  
7.     dup_str = strdup(string);  
8.     printf("%s/n", dup_str);  
9.     free(dup_str);  
10.     return 0;  
11. }  

 函数名: stricmp

功  能: 以大小写不敏感方式比较两个串
用  法: int stricmp(char *str1, char *str2);
举例：

[cpp]  view plain copy

1. #include <string.h>  
2. #include <stdio.h>  
3. int main(void)  
4. {  
5.    char *buf1 = "BBB", *buf2 = "bbb";  
6.    int ptr;  
7.    ptr = stricmp(buf2, buf1);  
8.    if (ptr > 0)  
9.       printf("buffer 2 is greater than buffer 1/n");  
10.    if (ptr < 0)  
11.       printf("buffer 2 is less than buffer 1/n");  
12.    if (ptr == 0)  
13.       printf("buffer 2 equals buffer 1/n");  
14.    return 0;  
15. }  

 函数名: strerror

功  能: 返回指向错误信息字符串的指针
用  法: char *strerror(int errnum);
举例：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <errno.h>  
3. int main(void)  
4. {  
5.    char *buffer;  
6.    buffer = strerror(errno);  
7.    printf("Error: %s/n", buffer);  
8.    return 0;  
9. }  

 函数名: strncmp

功  能: 串比较
用  法: int strncmp(char *str1, char *str2, int maxlen);
举例：

[cpp]  view plain copy

1. #include <string.h>  
2. #include <stdio.h>  
3. int  main(void)  
4. {  
5.    char *buf1 = "aaabbb", *buf2 = "bbbccc", *buf3 = "ccc";  
6.    int ptr;  
7.    ptr = strncmp(buf2,buf1,3);  
8.    if (ptr > 0)  
9.       printf("buffer 2 is greater than buffer 1/n");  
10.    else  
11.       printf("buffer 2 is less than buffer 1/n");  
12.    ptr = strncmp(buf2,buf3,3);  
13.    if (ptr > 0)  
14.       printf("buffer 2 is greater than buffer 3/n");  
15.    else  
16.       printf("buffer 2 is less than buffer 3/n");  
17.    return(0);  
18. }  

 函数名: strncmpi

功  能: 把串中的一部分与另一串中的一部分比较, 不管大小写
用  法: int strncmpi(char *str1, char *str2, int len);

举例：

[cpp]  view plain copy

1. #include <string.h>  
2. #include <stdio.h>  
3. int main(void)  
4. {  
5.    char *buf1 = "BBBccc", *buf2 = "bbbccc";  
6.    int ptr;  
7.    ptr = strncmpi(buf2,buf1,3);  
8.    if (ptr > 0)  
9.       printf("buffer 2 is greater than buffer 1/n");  
10.    if (ptr < 0)  
11.       printf("buffer 2 is less than buffer 1/n");  
12.    if (ptr == 0)  
13.       printf("buffer 2 equals buffer 1/n");  
14.    return 0;  
15. }  

 函数名: strnset

功  能: 将一个串中的所有字符都设为指定字符
用  法: char *strnset(char *str, char ch, unsigned n);
举例：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <string.h>  
3. int main(void)  
4. {  
5.    char *string = "abcdefghijklmnopqrstuvwxyz";  
6.    char letter = 'x';  
7.    printf("string before strnset: %s/n", string);  
8.    strnset(string, letter, 13);  
9.    printf("string after  strnset: %s/n", string);  
10.    return 0;  
11. }  

 函数名: strpbrk

功  能: 在串中查找给定字符集中的字符
用  法: char *strpbrk(char *str1, char *str2);
举例：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <string.h>  
3. int main(void)  
4. {  
5.    char *string1 = "abcdefghijklmnopqrstuvwxyz";  
6.    char *string2 = "onm";  
7.    char *ptr;  
8.    ptr = strpbrk(string1, string2);  
9.    if (ptr)  
10.       printf("strpbrk found first character: %c/n", *ptr);  
11.    else  
12.       printf("strpbrk didn't find character in set/n");  
13.    return 0;  
14. }  

 函数名: strrev

功  能: 串倒转
用  法: char *strrev(char *str);
举例：

[cpp]  view plain copy

1. #include <string.h>  
2. #include <stdio.h>  
3. int main(void)  
4. {  
5.    char *forward = "string";  
6.    printf("Before strrev(): %s/n", forward);  
7.    strrev(forward);  
8.    printf("After strrev():  %s/n", forward);  
9.    return 0;  
10. }  
11. /*运行结果： 
12. Before strrev(): string 
13. After strrev():  gnirts 
14. */  

 函数名: strstr

功  能: 在串中查找指定字符串的第一次出现
用  法: char *strstr(char *str1, char *str2);
举例：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <string.h>  
3. int main(void)  
4. {  
5.    char *str1 = "Borland International", *str2 = "nation", *ptr;  
6.    ptr = strstr(str1, str2);  
7.    printf("The substring is: %s/n", ptr);  
8.    return 0;  
9. }  

 函数名: strtod

功  能: 将字符串转换为double型值
用  法: double strtod(char *str, char **endptr);
举例：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. int main(void)  
4. {  
5.    char input[80], *endptr;  
6.    double value;  
7.    printf("Enter a floating point number:");  
8.    gets(input);  
9.    value = strtod(input, &endptr);  
10.    printf("The string is %s the number is %lf/n", input, value);  
11.    return 0;  
12. }  

 函数名: strtol

功  能: 将串转换为长整数
用  法: long strtol(char *str, char **endptr, int base);
举例：

[cpp]  view plain copy

1. #include <stdlib.h>  
2. #include <stdio.h>  
3. int main(void)  
4. {  
5.    char *string = "87654321", *endptr;  
6.    long lnumber;  
7.    /* strtol converts string to long integer  */  
8.    lnumber = strtol(string, &endptr, 10);  
9.    printf("string = %s  long = %ld/n", string, lnumber);  
10.    return 0;  
11. }  

 函数名: strupr

功  能: 将串中的小写字母转换为大写字母
用  法: char *strupr(char *str);
举例：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <string.h>  
3. int main(void)  
4. {  
5.    char *string = "abcdefghijklmnopqrstuvwxyz", *ptr;  
6.    /* converts string to upper case characters */  
7.    ptr = strupr(string);  
8.    printf("%s/n", ptr);  
9.    return 0;  
10. }