glibc接口函数 字符串处理

基本的字符串处理接口函数总结：

（字符串处理比较常用函数：printf、sprintf、svprintf、strcpy、strcat、strcmp、memset、memcpy、memmove、strstr、strchr、strstok、strstok_r、strlen、atoi、）

一、字符串转为数字（convert ASCII string to floating-point number or integer）

1. atof：字符串转浮点型函数

2. atoi：字符串转整型函数

3. atol：字符串转长整型函数

（strtod、strtol、strtof，这几个函数和上面的类似，但是加了错误检查。没有测试！！）

4. strtod：字符串转换成双精度函数

5. strtol：字符串转换成长整型函数

6. strtoul：字符串转换成无符号长整型函数

二、字符搜索函数（scan memory for a character）

1. memchr：字符搜索函数

 void *memchr(const void *s, int c, size_t n);

2. memrchr：字符逆向搜素函数

void *memrchr(const void *s, int c, size_t n);

三、字符串比较函数（compare two strings  OR compare memory areas）

1. memcmp：字符串比较函数

int memcmp(const void *s1, const void *s2, size_t n);

2. strncmp：字符串比较函数

int strncmp(const char *s1, const char *s2, size_t n);

3. strcmp：（compare two strings）

 int strcmp(const char *s1, const char *s2);

strncmp：比较前n个字节（ only compares the first (at most) n characters of s1 and s2.）

int strncmp(const char *s1, const char *s2, size_t n);

4. strcasecmp：忽略大小写的比较（compare two strings ignoring case）

int strcasecmp(const char *s1, const char *s2); 

int strncasecmp(const char *s1, const char *s2, size_t n);

四、字符串拷贝函数（copy memory area ）

1. memcpy： 字符串拷贝函数（不能出现覆盖overlap）

void *memcpy(void *dest, const void *src, size_t n);

2. memmove： 字块移动函数（可以overlap）

void *memmove(void *dest, const void *src, size_t n);

12. strcpy：字符串拷贝函数 11

20. strncpy：字符串子串拷贝函数 18

14. strdup：字符串新建拷贝函数 12

五、字符串置数函数

1. memset：字符加载函数（fill memory with a constant byte）

void *memset(void *s, int c, size_t n);、

24. strset：字符串设定函数 21

六、字符串连接函数

1. strcat：字符串连接函数

2. strncat：字符串部分连接函数

函数原型:char* strncat(char*dest,char*src,int n);

七、字符串中匹配字符或查找子串

1. strchr：字符串中字符首次匹配函数，字串中找字符（The strchr() function returns a pointer to the first occurrence of the character c in the string s.）

char *strchr(const char *s, int c);

2. strrchr：字符串中字符末次匹配函数（The strrchr() function returns a pointer to the last occurrence of the character c in the string s.）

char *strrchr(const char *s, int c);

3. strstr：提取子串函数（ locate a substring，The  strstr() function finds the first occurrence of the substring needle in the string haystack.  The terminating '\0' characters are not com-

       pared.）

char *strstr(const char *haystack, const char *needle);

char *strcasestr(const char *haystack, const char *needle);

（The strcasestr() function is like strstr(), but ignores the case of both arguments.）

4. strspn：字符集匹配函数（ The strspn() function calculates the length of the initial segment of s which consists entirely of characters in accept.）

size_t strspn(const char *s, const char *accept);

5. strcspn：字符集逆匹配函数（The strcspn() function calculates the length of the initial segment of s which consists entirely of characters not in reject.）

size_t strcspn(const char *s, const char *reject);

extract tokens from strings（提取分隔符间字串）

6. strtok：字符串分隔函数(The  strtok() function parses a string into a sequence of tokens.  On the first call to strtok() the string to be parsed should be specified in

       str.  In each subsequent call that should parse the same string, str should be NULL.)

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

strtok_r：( The  strtok_r()  function  is  a reentrant version strtok().  The saveptr argument is a pointer to a char * variable that is used internally by

       strtok_r() in order to maintain context between successive calls that parse the same string.)

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

注意：stotok和strtok_r如果要连续调用，则必须连续分解同一个字符串。

使用方法：

 for (str2 = token; ; str2 = NULL) {

                   subtoken = strtok_r(str2, argv[3], &saveptr2);

                   if (subtoken == NULL)

                       break;

                   printf(" --> %s\n", subtoken);

               }

search a string for any of a set of characters

7. strpbrk：字符集字符匹配函数(在字符串中查找第一个属于字符集的字符位置，也就是在字符串str1中查找第一个属于字符集str2中任意字符的位置。)

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

八、计算字符串长度

1. strlen：计算字符串长度函数

九、字符串错误信息函数

1. strerror：字符串错误信息函数（return string describing error number）

char *strerror(int errnum);

但是一般都是直接使用perror函数直接使用管道打印对应的错误就可以了。

void perror(const char *s);(print a system error message)

注意：使用这些函数的时候一定要注意函数的声明，如果是char* 类型的参数就一般不要传入一个字符串常量，因为这个参数大可能输入之后需要修改字符串中的内容，而对于const char * 类型的参数，则可以输入一个指向字符串常量的指针比较合适。

注意：如下内容我自己看了，感觉里面有个普片的问题就是：总是试图去修改字符串常量的内容，从而导致segment fault的错误产生。

如下内容，我自己看了下

如下内容《源于网络，归于网络》

之前在学习C语言的时候，知道C语言库函数中有很多字符串处理函数，但是没怎么好好利用它。最近，发现它们的作用实在太大了，而且有些是我从来都没有用过的。今天想整理一下，方便以后使用。比较容易理解的，就没有举例说明。

使用有关字符串处理的库函数，务必包含头文件string.h，即#include <string.h>

1、 比较字符串大小函数  

   1）忽略大小写---strcasecmp

  函数原型： int strcasecmp (const char *s1, const char *s2);

  函数说明： 用来比较参数s1和s2字符串，比较时会自动忽略大小写的差异

2）忽略大小写—stricmp

  函数原型：int stricmp(char *str1, char *str2);

  函数说明：以大小写不敏感方式比较两个串

3)不忽略大小写—strcmp

  函数原型：int strcmp(char*str1,char*str2);

  函数说明：通过比较字串中各个字符的ASCII码，来比较参数Str1和Str2字符串，比较时考虑字符的大小       写。

4）比较一部分—strncmpi

   函数原型：int strncmpi(char *str1, char *str2, unsigned maxlen);

   函数说明：比较字符串str1和str2的前maxlen个字符

5）内存区域比较---memcmp

   函数原型：int memcmp(void*buf1,void *buf2,unsigned int count)

   函数说明：比较内存区域buf1和buf2的前count个字节。Void*是指任何类型的指针。

6）内存区域部分比较-- memicmp Void*是指任何类型的指针。

   函数原型：int memicmp(void*buf1,void *buf2,unsigned int count)

   函数说明：比较内存区域buf1和buf2的前count个字节，但不区分大小写。

 

以上比较函数的返回值： 若参数1中字符串和参数中2字符串相同则返回0；

                        若参数1中字符串长度大于参数2中字符串长度则返回大于0 的值；

                        若参数1中字符串 长度小于参数2中字符串 长度则返回小于0的值。
2、从字符串中提取子串  

1）提取子串--strstr

   函数原型：char* strstr(char*src,char*find)

   函数说明：从字符串src中寻找find第一次出现的位置（不比较结束符NULL）

返回值：返回指向第一次出现find位置的指针，如果没有找到则返回NULL

2）提取分隔符间字串—strtok

   函数原型：char *strtok(char*src， char*delim);

   函数说明：分解字符串诶一组标记串，src为要分解的字符串，delim为分隔符字符串。

             首次调用时，src必须指向要分解的字符串，随后调用要把s设成NULL；

            strtok中src中查找包含在delim中的字符，并用NULL（’\0’）来替换直到找遍整个字符串。

   返回值：从s开头开始的一个个被分割的串。当没有被分割的串时则返回NULL。

            所有delim中包含的字符都会被滤掉，并将被滤掉的地方设为一处分割的节点。

举例：

    #include <string.h>

    #include <stdio.h>

    int main(){

        char *s="Golden Global View";

        char *d=" ";

        char *p;

         p=strtok(s,d);

        while(p){

          printf("%s\n",p);

          strtok(NULL,d);

        }

        return 0;

}

输出：Golden

      Global

      View

3、 字符串复制

   1) 字串复制--strcpy

      函数原型：char*strcpy(char*dest,char*src)

      函数说明：把src所指由NULL结束的字符串复制到dest所指的数组中。

              其中，src和dest所致内存区域不可重叠且dest必须有足够的空间来容纳src的字符串。

      返回值：返回指向dest的指针。

   2）字串复制--strdup

      函数原型：char* strdup(char*src)

      函数说明：复制字符串src

      返回值：返回指向被复制字符串的指针，所需空间有malloc（）分配且可以有free（）释放。

   3） 内存空间复制--memcpy

      函数原型：void *memcpy(void *dest,void *src,unsigned int count);

      函数说明：src和dest 所指内存区域不能重叠；由src所致内存区域复制count个字节到dest所指内            存区域中。

      返回值：返回指向dest的指针。

4、字符串连接   

   1）接尾连接--strcat

      函数原型：char* strcat(char*dest,char*src)

      函数说明：把src所指字符串添加到dest结尾处(覆盖dest结尾处的'\0')并添加'\0'

   2)部分连接--strncat

      函数原型:char* strncat(char*dest,char*src,int n);

      函数说明：把src所指字符串的前n个字符添加到dest结尾处（覆盖dest结尾处的’\0’）并添                加’\0’.

     返回值：返回指向dest的指针。

5、从字符串中查找字符

   1）内存区域找字符--memchr

      函数原型：void *memchr(void*buf,char ch,usigned count)

      函数说明：从buf所指内存区域的前count个字节查找字符ch，当第一次遇到字符ch时停止查找。

      返回值：如果找到了，返回指向字符ch的指针；否则返回NULL

   2）字串中找字符--strchr

      函数原型:char* strchr(char*src,char ch)

      函数说明：查找字符串s中首次出现字符ch的位置

      返回值：返回首次出现c的位置的指针，如果s中不存在c则返回NULL

   3）搜所现字符--strcspn

      函数原型：int strcspn（char*src,char*find）

      函数说明：在字符串src中搜寻find中所出现的字符

      返回值：返回第一个出现的字符在src中的下标值，即src中出现而不在find中出现的字串的长度。

举例：

#include <string.h>

#include <stdio.h>

int main(){

    char *s="Golden Global View";

    char *r="new";

    int n;

    n=strcspn(s,r);

    printf("The first char both in s1 and s2 is: %c",s[n]);

   return 0;

}

输出：The first char both in s1 and s2 is :e

   4)匹配任一字符--strpbrk

      函数原型：char*strpbrk(char*s1,char*s2)

      函数说明：在字符串S1中寻找字符串S2中任何一个字符相匹配的第一个字符的位置，空字符不包括在            内。

     返回值：返回指向S1中第一个相匹配的字符的指针，如果没有匹配字符则返回空指针。

举例：

#include <stdio.h>

#include <string.h>

int main(){

    char *s1="Welcome To Beijing";

    char *s2="BIT";

    char *p;

    p=strpbrk(s1,s2);

    if(p)

        printf("%s\n",p);

    else printf("Not Found!\n");

    return 0;

}

输出：To Beijing

6、其他函数

    1）全部转成大写---strupr

       函数原型：char*strupr(char*src)

       函数说明：将字符串src转换成大写形式，只转换src中出现的小写字母，不改变其他字符

       返回值：返回指向src的指针。

    2）全部转成小写---strlwr

       函数原型：char*strlwr(char*src)

       函数说明：将字符串src转换成小写形式，只转换src中出现的大写字母，不改变其他字符

       返回值：返回指向src的指针。

   3）将字串逆向--strrev

       函数原型：char*strrev（char*src）

       函数说明：把字符串src的所有字符的顺序颠倒过来（不包括NULL）

       返回值：返回指向颠倒顺序后的字符串指针

对于刚接触C语言的人们，字符串往往处理起来有点费力，我是很有感触的，刚开始用来做用户名和密码的时候调试了很久才出来，呵呵，再此我收集了C语言中关于字符串的函数，希望对大家能有帮助，中国IEEE希望大家能共同进步！~

       C语言字符串函数大全
       1.函数名: stpcpy
        功   能: 拷贝一个字符串到另一个
        用   法: char *stpcpy(char *destin, char *source);
程序例:
#include <stdio.h>
#include <string.h>
int main(void)
{
char string[10];
char *str1 = "abcdefghi";
stpcpy(string, str1);
printf("%s\n", string);
return 0;
}
  
        2.函数名: strcat
         功  能: 字符串拼接函数
         用  法: char *strcat(char *destin, char *source);
程序例:
#include <string.h>
#include <stdio.h>
int main(void)
{
char destination[25];
char *blank = " ", *c = "C++", *Borland = "Borland";
strcpy(destination, Borland);
strcat(destination, blank);
strcat(destination, c);
printf("%s\n", destination);
return 0;
}
  
         3.函数名: strchr
          功  能: 在一个串中查找给定字符的第一个匹配之处\
          用  法: char *strchr(char *str, char c);
程序例:
#include <string.h>
#include <stdio.h>
int main(void)
{
char string[15];
char *ptr, c = 'r';
strcpy(string, "This is a string");
ptr = strchr(string, c);
if (ptr)
   printf("The character %c is at position: %d\n", c, ptr-string);
else
   printf("The character was not found\n");
return 0;
}
  
          4.函数名: strcmp
           功  能: 串比较
           用  法: int strcmp(char *str1, char *str2);
看Asic码，str1>str2，返回值 > 0；两串相等，返回0
程序例:
#include <string.h>
#include <stdio.h>
int main(void)
{
char *buf1 = "aaa", *buf2 = "bbb", *buf3 = "ccc";
int ptr;
ptr = strcmp(buf2, buf1);
if (ptr > 0)
   printf("buffer 2 is greater than buffer 1\n");
else
   printf("buffer 2 is less than buffer 1\n");
ptr = strcmp(buf2, buf3);
if (ptr > 0)
   printf("buffer 2 is greater than buffer 3\n");
else
   printf("buffer 2 is less than buffer 3\n");
return 0;
}
  
          5.函数名: strncmpi
           功  能: 将一个串中的一部分与另一个串比较, 不管大小写
           用  法: int strncmpi(char *str1, char *str2, unsigned maxlen);
程序例:
#include <string.h>
#include <stdio.h>
int main(void)
{
char *buf1 = "BBB", *buf2 = "bbb";
int ptr;
ptr = strcmpi(buf2, buf1);
if (ptr > 0)
   printf("buffer 2 is greater than buffer 1\n");
if (ptr < 0)
   printf("buffer 2 is less than buffer 1\n");
if (ptr == 0)
   printf("buffer 2 equals buffer 1\n");
return 0;
}
  
         6.函数名: strcpy
          功  能: 串拷贝
          用  法: char *strcpy(char *str1, char *str2);
程序例:
#include <stdio.h>
#include <string.h>
int main(void)
{
char string[10];
char *str1 = "abcdefghi";
strcpy(string, str1);
printf("%s\n", string);
return 0;
}
  
          7.函数名: strcspn
           功  能: 在串中查找第一个给定字符集内容的段
           用  法: int strcspn(char *str1, char *str2);
程序例:
#include <stdio.h>
#include <string.h>
#include <alloc.h>
int main(void)
{
char *string1 = "1234567890";
char *string2 = "747DC8";
int length;
length = strcspn(string1, string2);
printf("Character where strings intersect is at position %d\n", length);
return 0;
}
  
         8.函数名: strdup
          功  能: 将串拷贝到新建的位置处
          用  法: char *strdup(char *str);
程序例:
#include <stdio.h>
#include <string.h>
#include <alloc.h>
int main(void)
{
char *dup_str, *string = "abcde";
dup_str = strdup(string);
printf("%s\n", dup_str);
free(dup_str);
return 0;
}
  
          9.函数名: stricmp
           功  能: 以大小写不敏感方式比较两个串
           用  法: int stricmp(char *str1, char *str2);
程序例:
#include <string.h>
#include <stdio.h>
int main(void)
{
char *buf1 = "BBB", *buf2 = "bbb";
int ptr;
ptr = stricmp(buf2, buf1);
if (ptr > 0)
   printf("buffer 2 is greater than buffer 1\n");
if (ptr < 0)
   printf("buffer 2 is less than buffer 1\n");
if (ptr == 0)
   printf("buffer 2 equals buffer 1\n");
return 0;
}

         10.函数名: strerror
           功  能: 返回指向错误信息字符串的指针
           用  法: char *strerror(int errnum);
程序例:
#include <stdio.h>
#include <errno.h>
int main(void)
{
char *buffer;
buffer = strerror(errno);
printf("Error: %s\n", buffer);
return 0;
}
  
         11.函数名: strcmpi
           功  能: 将一个串与另一个比较, 不管大小写
           用  法: int strcmpi(char *str1, char *str2);
程序例:
#include <string.h>
#include <stdio.h>
int main(void)
{
char *buf1 = "BBB", *buf2 = "bbb";
int ptr;
ptr = strcmpi(buf2, buf1);
if (ptr > 0)
   printf("buffer 2 is greater than buffer 1\n");
if (ptr < 0)
   printf("buffer 2 is less than buffer 1\n");
if (ptr == 0)
   printf("buffer 2 equals buffer 1\n");
return 0;
}

         12.函数名: strncmp
           功  能: 串比较
           用  法: int strncmp(char *str1, char *str2, int maxlen);
程序例:
#include <string.h>
#include <stdio.h>
int   main(void)
{
char *buf1 = "aaabbb", *buf2 = "bbbccc", *buf3 = "ccc";
int ptr;
ptr = strncmp(buf2,buf1,3);
if (ptr > 0)
   printf("buffer 2 is greater than buffer 1\n");
else
   printf("buffer 2 is less than buffer 1\n");
ptr = strncmp(buf2,buf3,3);
if (ptr > 0)
   printf("buffer 2 is greater than buffer 3\n");
else
   printf("buffer 2 is less than buffer 3\n");
return(0);
}

         13.函数名: strncmpi
           功  能: 把串中的一部分与另一串中的一部分比较, 不管大小写
           用  法: int strncmpi(char *str1, char *str2);
程序例:
#include <string.h>
#include <stdio.h>
int main(void)
{
char *buf1 = "BBBccc", *buf2 = "bbbccc";
int ptr;
ptr = strncmpi(buf2,buf1,3);
if (ptr > 0)
   printf("buffer 2 is greater than buffer 1\n");
if (ptr < 0)
   printf("buffer 2 is less than buffer 1\n");
if (ptr == 0)
   printf("buffer 2 equals buffer 1\n");
return 0;
}[/size]
[size=3]

         14.函数名: strncpy

           功  能: 串拷贝 

           用  法: char *strncpy(char *destin, char *source, int maxlen);

程序例:
#include <stdio.h>
#include <string.h>
int main(void)
{
char string[10];
char *str1 = "abcdefghi";
strncpy(string, str1, 3);
string[3] = '\0';
printf("%s\n", string);
return 0;
}

        15.函数名: strnicmp
          功  能: 不注重大小写地比较两个串
          用  法: int strnicmp(char *str1, char *str2, unsigned maxlen);
程序例:
#include <string.h>
#include <stdio.h>
int main(void)
{
char *buf1 = "BBBccc", *buf2 = "bbbccc";
int ptr;
ptr = strnicmp(buf2, buf1, 3);
if (ptr > 0)
   printf("buffer 2 is greater than buffer 1\n");
if (ptr < 0)
   printf("buffer 2 is less than buffer 1\n");
if (ptr == 0)
   printf("buffer 2 equals buffer 1\n");
return 0;
}
  
         16.函数名: strnset
           功  能: 将一个串中的所有字符都设为指定字符
           用  法: char *strnset(char *str, char ch, unsigned n);
程序例:
#include <stdio.h>
#include <string.h>
int main(void)
{
char *string = "abcdefghijklmnopqrstuvwxyz";
char letter = 'x';
printf("string before strnset: %s\n", string);
strnset(string, letter, 13);
printf("string after   strnset: %s\n", string);
return 0;
}

         17.函数名: strpbrk
           功  能: 在串中查找给定字符集中的字符
           用  法: char *strpbrk(char *str1, char *str2);
程序例:
#include <stdio.h>
#include <string.h>
int main(void)
{
char *string1 = "abcdefghijklmnopqrstuvwxyz";
char *string2 = "onm";
char *ptr;
ptr = strpbrk(string1, string2);
if (ptr)
   printf("strpbrk found first character: %c\n", *ptr);
else
   printf("strpbrk didn't find character in set\n");
return 0;
}
  
         18.函数名: strrchr
           功  能: 在串中查找指定字符的最后一个出现
           用  法: char *strrchr(char *str, char c);
程序例:
#include <string.h>
#include <stdio.h>
int main(void)
{
char string[15];
char *ptr, c = 'r';
strcpy(string, "This is a string");
ptr = strrchr(string, c);
if (ptr)
   printf("The character %c is at position: %d\n", c, ptr-string);
else
   printf("The character was not found\n");
return 0;
}
  
         19.函数名: strrev
           功  能: 串倒转
           用  法: char *strrev(char *str);
程序例:
#include <string.h>
#include <stdio.h>
int main(void)
{
char *forward = "string";
printf("Before strrev(): %s\n", forward);
strrev(forward);
printf("After strrev():   %s\n", forward);
return 0;
}
  
         20.函数名: strset
           功  能: 将一个串中的所有字符都设为指定字符
           用  法: char *strset(char *str, char c);
程序例:
#include <stdio.h>
#include <string.h>
int main(void)
{
char string[10] = "123456789";
char symbol = 'c';
printf("Before strset(): %s\n", string);
strset(string, symbol);
printf("After strset():   %s\n", string);
return 0;
}

         21.函数名: strspn
           功  能: 在串中查找指定字符集的子集的第一次出现
           用  法: int strspn(char *str1, char *str2);
程序例:
#include <stdio.h>
#include <string.h>
#include <alloc.h>
int main(void)
{
char *string1 = "1234567890";
char *string2 = "123DC8";
int length;
length = strspn(string1, string2);
printf("Character where strings differ is at position %d\n", length);
return 0;
}

         22.函数名: strstr
           功  能: 在串中查找指定字符串的第一次出现
           用  法: char *strstr(char *str1, char *str2);
程序例:
#include <stdio.h>
#include <string.h>
int main(void)
{
char *str1 = "Borland International", *str2 = "nation", *ptr;
ptr = strstr(str1, str2);
printf("The substring is: %s\n", ptr);
return 0;
}

         23.函数名: strtod
           功  能: 将字符串转换为double型值
           用  法: double strtod(char *str, char **endptr);
程序例:
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char input[80], *endptr;
double value;
printf("Enter a floating point number:");
gets(input);
value = strtod(input, &endptr);
printf("The string is %s the number is %lf\n", input, value);
return 0;
}

         24.函数名: strtok
           功  能: 查找由在第二个串中指定的分界符分隔开的单词
           用  法: char *strtok(char *str1, char *str2);
程序例:
#include <string.h>
#include <stdio.h>
int main(void)
{
char input[16] = "abc,d";
char *p;

p = strtok(input, ",");
if (p) printf("%s\n", p);

p = strtok(NULL, ",");
if (p) printf("%s\n", p);
return 0;
}

         25.函数名: strtol
           功  能: 将串转换为长整数
           用  法: long strtol(char *str, char **endptr, int base);
程序例:
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
char *string = "87654321", *endptr;
long lnumber;

lnumber = strtol(string, &endptr, 10);
printf("string = %s   long = %ld\n", string, lnumber);
return 0;
}
  
         26.函数名: strupr
           功  能: 将串中的小写字母转换为大写字母
           用  法: char *strupr(char *str);
程序例:
#include <stdio.h>
#include <string.h>
int main(void)
{
char *string = "abcdefghijklmnopqrstuvwxyz", *ptr;

ptr = strupr(string);
printf("%s\n", ptr);
return 0;
}

         27.函数名: swab
           功  能: 交换字节
           用  法: void swab (char *from, char *to, int nbytes);
程序例:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
char source[15] = "rFna koBlrna d";
char target[15];
int main(void)
{
swab(source, target, strlen(source));
printf("This is target: %s\n", target);
return 0;

}

转载：http://blog.163.com/helloworld_zhouli/blog/static/20337112120138325729876/