C语言字符串处理-优快云博客

转自：https ：//blog.youkuaiyun.com/Code_star_one/article/details/78260482

@函数名称：strtok

    函数原型:   char *strtok(char *s1, const char *s2) 
    函数功能:   分解s1字符串为用特定分隔符分隔的多个字符串(一般用于将英文句分解为单词) 
    函数返回:   字符串s1中首次出现s2中的字符前的子字符串指针 
    参数说明:   s2一般设置为s1中的分隔字符 
    规定进行子调用时（即分割s1的第二、三及后续子串）第一参数必须是NULL 
    在每一次匹配成功后，将s1中分割出的子串位置替换为NULL(摘下链中第一个环)，因此s1被破坏了 
    函数会记忆指针位置以供下一次调用 
    所属文件:   <string.h>

    #include <string.h> 
    #include <stdio.h> 
    int main() 
    { 
      char *p; 
      char *buffer; 
      char *delims={ " .," };

      buffer=strdup("Find words, all of them."); 
      printf("%s\n",buffer); 
      p=strtok(buffer,delims); 
      while(p!=NULL){ 
        printf("word: %s\n",p); 
        p=strtok(NULL,delims); 
      } 
      printf("%s\n",buffer); 
      return 0; 
    }

@函数名称：strdup

    函数原型:   char *strdup(const char *s) 
    函数功能:   字符串拷贝，目的空间由该函数分配  
    函数返回:   指向拷贝后的字符串指针 
    参数说明:   src-待拷贝的源字符串 
    所属文件:   <string.h>

    #include <stdio.h> 
    #include <string.h> 
    #include <alloc.h> 
    int main() 
    { 
      char *dup_str, *string="abcde"; 
      dup_str=strdup(string); 
      printf("%s", dup_str); 
      free(dup_str); 
      return 0; 
    }

@函数名称：strcpy

    函数原型:   char* strcpy(char* str1,char* str2); 
    函数功能:   把str2指向的字符串拷贝到str1中去 
    函数返回:   返回str1,即指向str1的指针 
    参数说明: 
    所属文件:   <string.h>

    #include <stdio.h> 
    #include <string.h> 
    int main() 
    { 
      char string[10]; 
      char *str1="abcdefghi"; 
      strcpy(string,str1); 
      printf("the string is:%s\n",string); 
      return 0; 
    }

函数名称：strncpy

    函数原型:   char *strncpy(char *dest, const char *src，int count) 
    函数功能:   将字符串src中的count个字符拷贝到字符串dest中去 
    函数返回:   指向dest的指针 
    参数说明:   dest-目的字符串，src-源字符串，count-拷贝的字符个数 
    所属文件:   <string.h>

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

函数名称：strcat

    函数原型:   char* strcat(char * str1,char * str2); 
    函数功能:   把字符串str2接到str1后面,str1最后的'\0'被取消 
    函数返回:   str1 
    参数说明: 
    所属文件:   <string.h>

    #include <stdio.h> 
    #include <string.h>

    int main() 
    { 
      char buffer[80];

      strcpy(buffer,"Hello "); 
      strcat(buffer,"world"); 
      printf("%s\n",buffer); 
      return 0; 
    }

函数名称：strncat

    函数原型:   char *strncat(char *dest, const char *src, size_t maxlen) 
    函数功能:   将字符串src中前maxlen个字符连接到dest中 
    函数返回: 
    参数说明: 
    所属文件:   <string.h>

    #include <stdio.h> 
    #include <string.h>

    char buffer[80];

    int main() 
    { 
      strcpy(buffer,"Hello "); 
      strncat(buffer,"world",8); 
      printf("%s\n",buffer); 
      strncat(buffer,"*************",4); 
      printf("%s\n",buffer); 
      return 0; 
    }

函数名称：strcmp

    函数原型:   int strcmp(char * str1,char * str2); 
    函数功能:   比较两个字符串str1,str2. 
    函数返回:   str1<str2,返回负数; str1=str2,返回 0; str1>str2,返回正数.  
    参数说明: 
    所属文件:   <string.h>

    #include <string.h> 
    #include <stdio.h> 
    int main() 
    { 
      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; 
    }

函数名称：strncmp

    函数原型:   int strncmp(char *str1,char *str2,int count) 
    函数功能:   对str1和str2中的前count个字符按字典顺序比较 
    函数返回:   小于0：str1<str2，等于0：str1=str2，大于0：str1>str2 
    参数说明:   str1,str2-待比较的字符串，count-比较的长度 
    所属文件:   <string.h>

    #include <string.h> 
    #include <stdio.h> 
    int main() 
    { 
      int ptr; 
       char *buf1="aaabbb",*buf2="bbbccc",*buf3="ccc"; 
      ptr=strncmp(buf2,buf1,3); 
      if (ptr>0) 
        printf("buffer 2 is greater than buffer 1"); 
      else 
        printf("buffer 2 is less than buffer 1"); 
        ptr=strncmp(buf2,buf3,3); 
      if (ptr>0) 
        printf("buffer 2 is greater than buffer 3"); 
      else 
        printf("buffer 2 is less than buffer 3"); 
      return(0); 
    }

函数名称：strpbrk

    函数原型:   char *strpbrk(const char *s1, const char *s2) 
    函数功能:   得到s1中第一个“同时也出现在s2中”字符的位置指针 
    函数返回:   位置指针 
    参数说明: 
    所属文件:   <string.h>

    #include <stdio.h> 
    #include <string.h> 
    int main() 
    { 
    char *p="Find all vowels";

    while(p) 
    { 
      printf("%s\n",p); 
      p=strpbrk(p+1,"aeiouAEIOU"); 
    } 
    return 0; 
    }

函数名称：strcspn

    函数原型:   int strcspn(const char *s1, const char *s2) 
    函数功能:   统计s1中从头开始直到第一个“来自s2中的字符”出现的长度 
    函数返回:   长度 
    参数说明: 
    所属文件:   <string.h>

    #include <stdio.h> 
    #include <string.h>

    int main() 
    { 
      printf("%d\n",strcspn("abcbcadef","cba")); 
      printf("%d\n",strcspn("xxxbcadef","cba")); 
      printf("%d\n",strcspn("123456789","cba")); 
      return 0; 
    }

函数名称：strspn

    函数原型:   int strspn(const char *s1, const char *s2) 
    函数功能:   统计s1中从头开始直到第一个“不来自s2中的字符”出现的长度 
    函数返回:   位置指针 
    参数说明: 
    所属文件:   <string.h>

    #include <stdio.h> 
    #include <string.h> 
    #include <alloc.h> 
    int main() 
    { 
      printf("%d\n",strspn("out to lunch","aeiou")); 
      printf("%d\n",strspn("out to lunch","xyz")); 
      return 0; 
    }

函数名称：strchr

    函数原型:   char* strchr(char* str,char ch); 
    函数功能:   找出str指向的字符串中第一次出现字符ch的位置 
    函数返回:   返回指向该位置的指针,如找不到,则返回空指针 
    参数说明:   str-待搜索的字符串，ch-查找的字符 
    所属文件:   <string.h>

    #include <string.h> 
    #include <stdio.h> 
    int main() 
    { 
      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; 
    }

函数名称：strrchr

    函数原型:   char *strrchr(const char *s, int c) 
    函数功能:   得到字符串s中最后一个含有c字符的位置指针 
    函数返回:   位置指针 
    参数说明: 
    所属文件:   <string.h>

    #include <string.h> 
    #include <stdio.h> 
    int main() 
    { 
      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",c,ptr-string); 
      else 
        printf("The character was not found"); 
      return 0; 
}

函数名称：strstr

    函数原型:   char* strstr(char* str1,char* str2); 
    函数功能:   找出str2字符串在str1字符串中第一次出现的位置(不包括str2的串结束符) 
    函数返回:   返回该位置的指针,如找不到,返回空指针 
    参数说明: 
    所属文件:   <string.h>

    #include <stdio.h> 
    #include <string.h> 
    int main() 
    { 
      char *str1="Open Watcom C/C++",*str2="Watcom",*ptr; 
      ptr=strstr(str1,str2); 
      printf("The substring is:%s\n",ptr); 
      return 0; 
    }

函数名称：strrev

     函数原型:   char *strrev(char *s) 
    函数功能:   将字符串中的所有字符颠倒次序排列 
    函数返回:   指向s的指针  
    参数说明: 
    所属文件:   <string.h>

    #include <string.h> 
    #include <stdio.h> 
    int main() 
    { 
      char *forward="string"; 
      printf("Before strrev():%s",forward); 
      strrev(forward); 
      printf("After strrev(): %s",forward); 
      return 0; 
    }

函数名称：strnset

    函数原型:   char *strnset(char *s, int ch, size_t n) 
    函数功能:   将字符串s中前n个字符设置为ch的值 
    函数返回:   指向s的指针 
    参数说明: 
    所属文件:   <string.h>

    #include <stdio.h> 
    #include <string.h> 
    int main() 
    { 
      char *string="abcdefghijklmnopqrstuvwxyz"; 
      char letter='x'; 
      printf("string before strnset: %s",string); 
      strnset(string,letter,13); 
      printf("string after strnset: %s",string); 
      return 0; 
    }

函数名称：strset

    函数原型:   char *strset(char *s, int ch) 
    函数功能:   将字符串s中所有字符设置为ch的值 
    函数返回:   指向s的指针  
    参数说明: 
    所属文件:   <string.h>

    #include <stdio.h> 
    #include <string.h> 
    int main() 
    { 
      char string[10]="123456789"; 
      char symbol='c'; 
      printf("Before strset(): %s", string); 
      strset(string, symbol); 
      printf("After strset(): %s", string); 
      return 0; 
    }

函数名称：strtok

    函数原型:   char *strtok(char *s1, const char *s2) 
    函数功能:   分解s1字符串为用特定分隔符分隔的多个字符串(一般用于将英文句分解为单词) 
    函数返回:   字符串s1中首次出现s2中的字符前的子字符串指针 
    参数说明:   s2一般设置为s1中的分隔字符 
    规定进行子调用时（即分割s1的第二、三及后续子串）第一参数必须是NULL 
    在每一次匹配成功后，将s1中分割出的子串位置替换为NULL(摘下链中第一个环)，因此s1被破坏了 
    函数会记忆指针位置以供下一次调用 

    所属文件:   <string.h>

    #include <string.h> 
    #include <stdio.h> 
    int main() 
    { 
      char *p; 
      char *buffer; 
      char *delims={ " .," };

      buffer=strdup("Find words, all of them."); 
      printf("%s\n",buffer); 
      p=strtok(buffer,delims); 
      while(p!=NULL){ 
        printf("word: %s\n",p); 
        p=strtok(NULL,delims); 
      } 
      printf("%s\n",buffer); 
      return 0; 
    }

@函数名称：strupr

    函数原型:   char *strupr(char *s) 
    函数功能:   将字符串s中的字符变为大写 
    函数返回: 
    参数说明: 
    所属文件:   <string.h>

    #include <stdio.h> 
    #include <string.h> 
    int main() 
    { 
      char *string="abcdefghijklmnopqrstuvwxyz",*ptr; 
      ptr=strupr(string); 
      printf("%s",ptr); 
      return 0; 
    }

@函数名称：strlwr

    函数原型:   char *strlwr(char *s) 
    函数功能:   将字符串中的字符变为小写字符 
    函数返回:   指向s的指针 
    参数说明: 
    所属文件:   <string.h>

    #include<string.h> 
    int main() 
    { 
      char str[]="HOW TO SAY?"; 
      printf("%s",strlwr(str)); 
      return 0; 
    }

@函数名称：strlen

函数原型:   unsigned int strlen(char * str); 
函数功能:   统计字符串str中字符的个数(不包括终止符'\0') 
函数返回:   返回字符串的长度. 
参数说明: 
所属文件:   <string.h>

    #include <stdio.h> 
    #include<string.h> 
    int main() 
    { 
      char str[]="how are you!"; 
      printf("the lence is:%d\n",strlen(str)); 
      return 0; 
    }

@函数名称：strerror

函数原型:   char *strerror(int errnum) 
函数功能:   得到错误信息的内容信息 
函数返回:   错误提示信息字符串指针 
参数说明:   errnum-错误编号 
所属文件:   <string.h>

    #include <stdio.h> 
    #include <errno.h> 
    int main() 
    { 
      char *buffer; 
      buffer=strerror(errno); 
      printf("Error: %s",buffer); 
      return 0; 
    }

@函数名称：memcpy

函数原型:   void *memcpy(void *dest, const void *src, size_t n) 
函数功能:   字符串拷贝 
函数返回:   指向dest的指针 
参数说明:   src-源字符串，n-拷贝的最大长度 
所属文件:   <string.h>,<mem.h>

    #include <stdio.h> 
    #include <string.h> 
    int main() 
    { 
      char src[]="******************************"; 
      char dest[]="abcdefghijlkmnopqrstuvwxyz0123456709"; 
      char *ptr; 
      printf("destination before memcpy:%s\n",dest); 
      ptr=memcpy(dest,src,strlen(src)); 
      if (ptr) 
        printf("destination after memcpy:%s\n",dest); 
      else 
        printf("memcpy failed"); 
      return 0; 
    }

@函数名称：memccpy

函数原型:   void *memccpy(void *dest, const void *src, int c, size_t n) 
函数功能:   字符串拷贝，到指定长度或遇到指定字符时停止拷贝 
函数返回: 
参数说明:   src-源字符串指针，c-中止拷贝检查字符，n-长度,dest-拷贝底目的字符串指针 
所属文件:   <string.h>,<mem.h>

    #include <string.h> 
    #include <stdio.h> 
    int main() 
    { 
      char *src="This is the source string"; 
      char dest[50]; 
      char *ptr; 
      ptr=memccpy(dest,src,'c',strlen(src)); 
      if (ptr) 
      { 
        *ptr='\0'; 
        printf("The character was found:%s",dest); 
      } 
      else 
        printf("The character wasn't found"); 
      return 0; 
    }

@函数名称：memchr

函数原型:   void *memchr(const void *s, int c, size_t n) 
函数功能:   在字符串中第开始n个字符中寻找某个字符c的位置 
函数返回:   返回c的位置指针，返回NULL时表示未找到 
参数说明:   s-要搜索的字符串，c-要寻找的字符，n-指定长度 
所属文件:   <string.h>,<mem.h>

    #include <string.h> 
    #include <stdio.h> 
    int main() 
    { 
      char str[17]; 
      char *ptr; 
      strcpy(str,"This is a string"); 
      ptr=memchr(str,'r',strlen(str)); 
      if (ptr) 
      printf("The character 'r' is at position: %d",ptr-str); 
      else 
      printf("The character was not found"); 
      return 0; 
    }

@函数名称：memcmp

函数原型:   int memcmp(const void *s1, const void *s2,size_t n) 
函数功能:   按字典顺序比较两个串s1和s2的前n个字节  
函数返回:   <0,=0,>0分别表示s1<,=,>s2 
参数说明:   s1,s2-要比较的字符串，n-比较的长度 
所属文件:   <string.h>,<mem.h>

    #include <stdio.h> 
    #include <string.h> 
    int main()  
    {  
      char *buf1="ABCDE123";  
      char *buf2="abcde456";  
      int stat;  
      stat=memcmp(buf1,buf2,5);  
      printf("The strings to position 5 are ");  
      if(stat) printf("not ");  
      printf("the same\n");  
      return 0;  
    }

@函数名称：memicmp

函数原型:   int memicmp(const void *s1, const void *s2, size_t n) 
函数功能:   按字典顺序、不考虑字母大小写对字符串s1,s2前n个字符比较 
函数返回:   <0,=0,>0分别表示s1<,=,>s2 
参数说明:   s1,s2-要比较的字符串，n-比较的长度 
所属文件:   <string.h>,<mem.h>

    #include <stdio.h> 
    #include <string.h> 
    int main() 
    { 
      char *buf1="ABCDE123"; 
      char *buf2="abcde456"; 
      int stat; 
      stat=memicmp(buf1,buf2,5); 
      printf("The strings to position 5 are "); 
      if(stat) printf("not"); 
      printf("the same"); 
      return 0; 
    }

@函数名称：memmove

函数原型:   void *memmove(void *dest, const void *src, size_t n) 
函数功能:   字符串拷贝 
函数返回:   指向dest的指针 
参数说明:   src-源字符串，n-拷贝的最大长度 
所属文件:   <string.h>,<mem.h>

    #include <string.h> 
    #include <stdio.h> 
    int main() 
    { 
      char dest[40]="abcdefghijklmnopqrstuvwxyz0123456789"; 
      printf("destination prior to memmove:%s\n",dest); 
      memmove(dest+1,dest,35); 
      printf("destination after memmove:%s",dest); 
      return 0; 
    }

@函数名称：memset

函数原型:   void *memset(void *s, int c, size_t n) 
函数功能:   字符串中的n个字节内容设置为c 
函数返回: 
参数说明:   s-要设置的字符串，c-设置的内容，n-长度 
所属文件:   <string.h>,<mem.h>

    #include <string.h> 
    #include <stdio.h> 
    #include <mem.h> 
    int main() 
    { 
      char buffer[]="Hello world"; 
      printf("Buffer before memset:%s\n",buffer); 
      memset(buffer,'*',strlen(buffer)-1); 
      printf("Buffer after memset:%s",buffer); 
      return 0; 
    }

转：http : //guangming008.blog.163.com/blog/static/12039682008238485736/

1）字符串操作

strcpy（p，p1）复制字符串

strncpy（p，p1，n）复制指定长度字符串

strcat（p，p1）附加字符串

strncat（p，p1，n）附加指定长度字符串

strlen（p）取字符串长度

strcmp（p，p1）比较字符串

strcasecmp忽略大小写比较字符串

strncmp（p，p1，n）比较指定长度字符串

strchr（p，c）在字符串中查找指定字符

strrchr（p，c）在字符串中反向查找

strstr（p，p1）查找字符串

strpbrk（p，p1）以目标字符串的所有字符作为集合，在当前字符串查找该集合的任一元素

strspn（p，p1）以目标字符串的所有字符作为集合，在当前字符串查找不属于该集合的任一元素的偏移

strcspn（p，p1）以目标字符串的所有字符作为集合，在当前字符串查找属于该集合的任一元素的偏移

具有指定长度的字符串处理函数在已处理的字符串之后填补零结尾符

2）字符串到数值类型的转换

strtod（p，ppend）从字符串p中转换double类型数值，并将后续的字符串指针存储到ppend指向的char *类型存储。

strtol（p，ppend，base）从字符串p中转换long类型整型数值，base显式设置转换的整型进制，设置为0以根据特定格式判断所用进制，0x，0X前缀以解释为十六进制格式整型，0前缀以解释为八进制格式整型

atoi（p）字符串转换到int整型

atof（p）字符串转换为双符点数

atol（p）字符串转换到long整型

3）字符检查

isalpha（）检查是否为字母字符

isupper（）检查是否为大写字母字符

islower（）检查是否为小写字母字符

isdigit（）检查是否为数字

isxdigit（）检查是否为十六进制数字表示的有效字符

isspace（）检查是否为空格类型字符

iscntrl（）检查是否为控制字符

ispunct（）检查是否为标点符号

isalnum（）检查是否为字母和数字

isprint（）检查是否是可打印字符

isgraph（）检查是否是图形字符，等效于isalnum（）| ispunct判断（）

4）函数原型

原型：strcpy（char destination []，const char source []）;
功能：将字符串源拷贝到字符串目的地中
例程：

    #include <iostream.h> 
    #include <string.h> 
    void main(void) 
    { 
    　 char str1[10] = { "TsinghuaOK"}; 
    　 char str2[10] = { "Computer"}; 
    　 cout <<strcpy(str1,str2)<<endl; 
    }

运行结果是：计算机
第二个字符串将覆盖掉第一个字符串的所有内容！
注意：在定义数组时，字符数组1的字符串长度必须大于或等于字符串2的字符串长度不能用赋值语句将一个字符串常量或字符数组直接赋给一个字符数组。所有字符串处理函数都包含在头文件string.h中中。

strncpy函数应用举例
原型：strncpy（char destination []，const char source []，int numchars）;
功能：将字符串源中前缀numchars个字符拷贝到字符串目的地中
例程：

    #include <iostream.h> 
    #include <string.h> 
    void main(void) 
    { 
    　 char str1[10] = { "Tsinghua "}; 
    　 char str2[10] = { "Computer"}; 
    　 cout <<strncpy(str1,str2,3)<<endl; 
    }

运行结果：Comnghua
注意：字符串源中前NUMCHARS个字符将覆盖掉字符串目的地中前NUMCHARS个字符！

原型：strcat（char target []，const char source []）;
功能：将字符串source接到字符串target的后面
例程：

#include <iostream.h> 
#include <string.h> 
void main(void) 
{ 
　 char str1[] = { "Tsinghua "}; 
　 char str2[] = { "Computer"}; 
　 cout <<strcpy(str1,str2)<<endl; 
}

运行结果：清华计算机

注意：在定义字符数组1的长度时应该考虑字符数组2的长度，因为连接后新字符串的长度为两个字符串长度之和进行字符串连接后，字符串1的结尾符将自动被去掉，在结尾串末尾保留新字符串后面一个结尾符。

原型：strncat（char target []，const char source []，int numchars）;
功能：将字符串源的前numchars个字符接到字符串目标的后面
例程：

#include <iostream.h> 
#include <string.h> 
void main(void) 
{ 
　 char str1[] = { "Tsinghua "}; 
　 char str2[] = { "Computer"}; 
　 cout <<strncat(str1,str2,3)<<endl; 
}

运行结果：Tsinghua Com

原型：int strcmp（const char firststring []，const char seconds）;
功能：比较两个字符串firststring和
secondstring例程：

#include <iostream.h> 
#include <string.h> 
void main(void) 
{ 
　 char buf1[] = "aaa"; 
　 char buf2[] = "bbb"; 
　 char buf3[] = "ccc"; 
　 int ptr;  
　 ptr = strcmp(buf2,buf1);  
　 if(ptr > 0) 
　　 cout <<"Buffer 2 is greater than buffer 1"<<endl; 
　 else  
　　 cout <<"Buffer 2 is less than buffer 1"<<endl; 
　 ptr = strcmp(buf2,buf3);  
　 if(ptr > 0) 
　　 cout <<"Buffer 2 is greater than buffer 3"<<endl; 
　 else  
　　 cout <<"Buffer 2 is less than buffer 3"<<endl; 
}

运行结果是：缓冲区2小于缓冲区1
缓冲区2大于缓冲区3

原型：strlen（const char string []）;
功能：统计字符串字符串中字符的个数
例程：

#include <iostream.h> 
#include <string.h> 
void main(void) 
{ 
  char str[100];  
  cout <<"请输入一个字符串:"; 
  cin >>str; 
  cout <<"The length of the string is :"<<strlen(str)<<"个"<<endl; 
}

运行结果字符串的长度是x（x为你输入的字符总数字）

注意：strlen的函数的功能是计算字符串的实际长度，不包括 '\ 0' 在内另外，strlen的函数也可以直接测试字符串常量的长度，如：strlen的（“欢迎”）。

void * memset（void * dest，int c，size_t count）;
将dest前面数count个字符置为字符c。返回DEST的值。

void * memmove（void * dest，const void * src，size_t count）;
从src复制计数字节的字符到dest。如果src和dest出现重叠，函数会自动处理。返回DEST的值。

void * memcpy（void * dest，const void * src，size_t count）;
从src复制count字节的字符到dest。与memmove功能一样，只是不能处理src和dest出现重叠。返回DEST的值。

void *memchr(const void *buf, int c, size_t count);
在buf前面count字节中查找首次出现字符c的位置. 找到了字符c或者已经搜寻了count个字节, 查找即停止. 操作成功则返回buf中首次出现c的位置指针, 否则返回NULL.

void *_memccpy(void *dest, const void *src, int c, size_t count);
从src复制0个或多个字节的字符到dest. 当字符c被复制或者count个字符被复制时, 复制停止.

如果字符c被复制, 函数返回这个字符后面紧挨一个字符位置的指针. 否则返回NULL.

int memcmp(const void *buf1, const void *buf2, size_t count);
比较buf1和buf2前面count个字节大小.
返回值< 0, 表示buf1小于buf2;
返回值为0, 表示buf1等于buf2;
返回值> 0, 表示buf1大于buf2.

int memicmp(const void *buf1, const void *buf2, size_t count);

比较buf1和buf2前面count个字节. 与memcmp不同的是, 它不区分大小写.

返回值同上.

char *strrev(char *string);
将字符串string中的字符顺序颠倒过来. NULL结束符位置不变. 返回调整后的字符串的指针.

char * _strupr（char * string）;
将字符串中所有小写字母替换成相应的大写字母，其它字符保持不变。返回调整后的字符串的指针。

char * _strlwr（char * string）;
将字符串中所有大写字母替换成相应的小写字母，其它字符保持不变。返回调整后的字符串的指针。

char * strchr（const char * string，int c）;
查找字串中的中首次出现的位置，NULL结束符也包含在查找中。返回一个指针，指向字符c在字符串string中首次出现的位置，如果没有找到，则返回NULL。

char * strrchr（const char * string，int c）;
查找字符c在字符串string中最后一次出现的位置，也就是对字符串进行反序搜索，包含NULL结束符。
返回一个指针，指向字符c在字符串串中最后一次出现的位置，如果没有找到，则返回NULL。

char * strstr（const char * string，const char * strSearch）;
在字符串string中查找strSearch子串。返回子串strSearch在字符串中首次出现位置的指针。如果没有找到子串strSearch，则返回NULL。如果子串strSearch为空串，函数返回字符串值。

char * strdup（const char * strSource）;
函数运行中会自己调用malloc函数为复制strSource字符串分配存储空间，然后再将strSource复制到分配到的空间中。注意要及时释放这个分配的空间。
返回一个指针，指向为复制字符串分配的空间; 如果分配空间失败，则返回NULL值。

char * strcat（char * strDestination，const char * strSource）;
将源串strSource添加到目标串strDestination后面，并在得到的新串后面加上NULL结束符。源串strSource的字符会覆盖目标串strDestination后面的结束符NULL。在字符串的复制或添加过程中没有溢出检查，所以要保证目标串空间足够大。不能处理源串与目标串重叠的情况。函数返回strDestination值。

char * strncat（char * strDestination，const char * strSource，size_t count）;
将源串strSource开始的count个字符添加到目标串strDest后。源串strSource的字符会覆盖目标串strDestination后面的结束符NULL。如果计算大于源串长度，则会用源串的长度值替换计数值。得到的新串后面会自动加上NULL结束符。与strcat函数一样，本函数不能处理源串与目标串重叠的情况。函数返回strDestination值。

char * strcpy（char * strDestination，const char * strSource）;
复制源串strSource到目标串strDestination所指定的位置，包含NULL结束符。不能处理源串与目标串重叠的情况。函数返回strDestination值。

char * strncpy（char * strDestination，const char * strSource，size_t count）;
将源串strSource开始的count个字符复制到目标串strDestination所指定的位置。如果count值小于或等于strSource串的长度，不会自动添加NULL结束符目标串中，而count大于strSource串的长度时，则将strSource用NULL结束符填充补数count个字符，复制到目标串中。不能处理源串与目标串重叠的情况。函数返回strDestination值。

char * strset（char * string，int c）;
将字符串串的所有字符设置为字符c，遇到NULL结束符停止。函数返回内容调整后的字符串指针。

char * strnset（char * string，int c，size_t count）;
将字符串串开始计数个字符设置为字符c，如果计数值大于串串的长度，将用字符串的长度替换计数值。函数返回内容调整后的字符串指针。

size_t strspn(const char *string, const char *strCharSet);
查找任何一个不包含在strCharSet串中的字符 (字符串结束符NULL除外) 在string串中首次出现的位置序号. 返回一个整数值, 指定在string中全部由characters中的字符组成的子串的长度. 如果string以一个不包含在strCharSet中的字符开头, 函数将返回0值.

size_t strcspn(const char *string, const char *strCharSet);
查找strCharSet串中任何一个字符在string串中首次出现的位置序号, 包含字符串结束符NULL.
返回一个整数值, 指定在string中全部由非characters中的字符组成的子串的长度. 如果string以一个包含在strCharSet中的字符开头, 函数将返回0值.

char *strspnp(const char *string, const char *strCharSet);
查找任何一个不包含在strCharSet串中的字符 (字符串结束符NULL除外) 在string串中首次出现的位置指针. 返回一个指针, 指向非strCharSet中的字符在string中首次出现的位置.

char *strpbrk(const char *string, const char *strCharSet);
查找strCharSet串中任何一个字符在string串中首次出现的位置, 不包含字符串结束符NULL.
返回一个指针, 指向strCharSet中任一字符在string中首次出现的位置. 如果两个字符串参数不含相同字符, 则返回NULL值.

int strcmp（const char * string1，const char * string2）;
比较字符串string1和string2大小。
返回值<0，表示string1小于string2;
返回值为0，表示string1等于string2;
返回值> 0，表示string1大于字符串2。

int stricmp（const char * string1，const char * string2）;
比较字符串string1和string2大小，和strcmp不同，比较的是它们的小写字母版本。返回值与strcmp相同。

int strcmpi（const char * string1，const char * string2）;
等价于stricmp函数，只是提供一个向后兼容的版本。

int strncmp（const char * string1，const char * string2，size_t count）;
比较字符串string1和string2大小，只比较前面count个字符。比较过程中，任何一个字符串的长度小于count，则count将被较短的字符串的长度取代。此时如果两串前面的字符都相等，则较短的串要小。
返回值<0，表示串1的子串小于串2的子串;
返回值为0，表示串1的子串等于串2的子串;
返回值> 0，表示string1的子串大于string2的子串。

int strnicmp（const char * string1，const char * string2，size_t count）;
比较字符串string1和string2大小，只比较前面count个字符。与strncmp不同的是，比较的是它们的小写字母版本。返回值与STRNCMP相同。

字符*的strtok（字符* strToken，常量字符* strDelimit）;
在strToken串中查找下一个标记，strDelimit字符集则指定了在当前查找调用中可能遇到的分界符。返回一个指针，指向在strToken中找到的下一个标记。如果找不到标记，就返回NULL值。每次调用都会修改strToken内容，用NULL字符替换遇到的每个分界符。

C ++概念字符串操作

一，char_traits字符特征类
1）意义：包装特定串元素的通用行为界面，以便容器实现时依据特征信息而执行特定行为
2）定义了通用类型名

typedef _Elem char_type;
typedef int int_type;
typedef streampos pos_type;
typedef streamoff off_type;
typedef mbstate_t state_type;

其中INT_TYPE表示字符元素转换到特定编码时的整型表示，pos_type，off_type分别作为字符串索引和字符串元素偏移的类型，类似容器迭中的指针，迭代类型和指针，迭代器的偏移类型。最后的state_type用于存储流状态，如出错，格式控制等等。

3）定义了字符/字符串操作的包装界面，以便通用算法的调用

assign（a，b）定义将b字符赋值给字母的过程，实现a.operator =的行为
eq（a，b）定义a字符和b字符的相等关系，实现a.operator ==的行为
lt a，b）定义a小于b的关系，实现
a.operator <的行为 compare（a_ptr，b_ptr，cnt）定义两个字符串的比较，返回int类型，实现类似memcmp的行为
length（ptr）定义取字符串长度，实现类似strlen的行为
copy（a_ptr，b_ptr，cnt）定义两组字符串的复制，实现类似memcpy的行为
move（a_ptr，b_ptr，cnt）定义两组字符串的不重叠复制，实现类似memmove的行为
assign（ptr，cnt，ch）定义了填充字符串的过程，实现类似memset的行为
to_int_type（ch）定义了char_type到int_type整型的转换过程
to_char_type（n）定义了int_type到char_type字符型的转换过程
eq_int_type（a，b）定义两个和当前char_type类型对应的int_type的相等关系
eof（）定义字符串结尾符，使用整型表示
not_eof（n）定义非字符串结尾符，若输入结尾符，则返回1，其他输入返回原值，即总是不返回eof（）

4）int_type类型应是当前字符类型的整型编码

二，std :: string并不是序列容器，没有front（）和back（）界面用于取出前端和尾端的元素，使用std :: string :: operator []并传递streampos类型取得特定元素，如std：：string :: size（） - 1作为索引取得最后一个字符

三，basic_string支持的初始化
1）默认
初始化2）分配器
3）复制构造
4）局部复制[_Roff，_Roff + _Count）
5）局部复制+分配器
6）C字符串[_Ptr，）
7）C字符串+ _Count [_Ptr，_Ptr + _Count）
8）C字符串+分配器
9）C字符串+ _Count +分配器[_Ptr，_Ptr + _Count）

10）_Count * _Ch
11）_Count * _Ch +分配器
12）迭代器[_ItF，_ItL）
13）迭代器+分配器

字符到串不能初始化，但支持运算符=赋值和运算符+ =累加赋值运算。

四，的字符串区间有效性
对串的索引访问在超过字符串的有效值区间时，因为串的在实现上对内置的字符缓冲区执行下标访问，所以不会导致异常，但是将得到不可预知的结果，通常是不可用的。
将其他字符串作为右值输入时，对该串取出计数大于串大小时按串大小计算。
标准:: basic_string的:: SIZE_TYPE的实际类型为为size_t，在视觉C ++ 7.1中实现为unsigned，std :: basic_string :: npos被静态设定为

（basic_string <_Elem，_Traits，_Alloc> :: size_type）（ - 1）;

在查找子字符串等操作时，函数返回npos的值表示非法索引。

五，比较字符串
允许的比较对象
1）compare（s2）其他同类型字符串
2）compare（p）C风格字符串
3）compare（off，cnt，s2）[off，off + cnt）同s2执行比较
4）比较（关闭，CNT，S2，OFF2，CNT2）[关，关+ CNT）同S2 [OFF2，CNT2）执行比较
5）比较（关闭，CNT，p）[关，关+ CNT）同[ p，）执行比较
6）compare（off，cnt，p，cnt2）[off，off + cnt）同[p，p + cnt2）执行比较

返回-1，0，1作为小于，等于和大于的比较结果。

六，附加数据
1）使用operator + =接受其他字符串，C风格字符串和字符
2）使用push_back（）在尾部附加字符，并使得通过字符串构造的back_iterator可以访问
3）append（）附加
1， append（s）追加字符串
2，append（s，off，cnt）追加字符串s [off，off + cnt]
3，append（p）追加字符串[p，）
4，追加（p，cnt）追加字符串[p，p + cnt]
5，append（n，c）填充n * c
6，追加（InF，InL）追加输入流[InF，InL）

4）insert（）插入
1，插入（off，s2）插入字符串
2，插入（off，s2，off2，cnt2）插入字符串s [off2，off2 + cnt2）
3，插入（off，p）插入字符串[p，）
4，插入（off，p，cnt）插入字符串[p，p + cnt）

    5、insert(off, n, c) 插入 n * c 
    6、insert(iter) 元素默认值填充 
    7、insert(iter, c) 插入特定元素 
    8、insert(iter, n, c) 插入 n*c 
    9、insert(iter, InF, InL) 插入 [InF, InL)

5）operator +（a，b）
字符串关联运算符重载中支持operator +的形式
1，s + s
2，s + p
3，s + c
4，p + s
5，c + s

七，查找，替换和清除
1）find（）查找
1，find（c，off）在s [off，npos）中查找c
2，find（p，off，n）在s [off，npos） [p，p + N）
3，发现（p，关闭）在S [关，非营利组织）中查找[p，）
4，查找（S2，关闭）在S [关，非营利组织）中查找S2

2）find（）的变种
1，rfind（）具有find（）的输入形式，反序查找
2，find_first_of（）具有find（）的输入形式，返回第一个匹配的索引
3，find_last_of （）的输入形式，返回倒数第一个匹配的索引
4，find_first_not_of（）具有find（）的输入形式，返回第一个不匹配的索引
5，find_last_not_of（）具有find（）的输入形式，返回倒数第一个不匹配的索引

3）replace（）替换
1，replace（off，cnt，s2）将s [off，off + cnt）
替换成s2 2，replace（off，cnt，s2，off2，cnt2）将s [off，off + cnt ）
替换成s2 [off2，off2 + cnt2] 3，replace（off，cnt，p）将s [off，off + cnt）
替换成[p，） 4，replace（off，cnt，p，cnt2）将s [off，off + cnt]替换成[p，p + cnt2）

    5、replace(off, cnt, n, c) 将 s [off, off + cnt) 替换成 c * n

使用迭代器的情况：
6，替换（InF，InL，s2）将[InF，InL]
替换成s2 7，替换（InF，InL，p）将[InF，InL]
替换成[p，（InF，InL，p，cnt）将[InF，InL]
替换成[p，p + cnt] 9，替换（InF，InL，n，c）将[InF，InL]
替换成n * c 10，替换（InF，InL，InF2，InL2）将[InF，InL）替换成[InF2，InL2）

4）erase（）删除
1，erase（off，cnt）从字符串中删除s [off，off + cnt）
2，erase（iter）从字符串中删除* iter
3，erase（ItF，ItL）从字符串s中删除[ItF，ItL）

八，取出字符串
1）取得C风格字符串
c_str（）返回常量类型的C风格字符串指针，copy（ptr，cnt，off = 0）则将指定大小的字符串复制到特定指针.data（）在视觉C ++ 7.1中仅仅调用了c_str（）实现。
2）取得子字符串
SUBSTR（关闭，CNT）取得S [关，关+ CNT）的副本。
3）复制子字符串
复制（p，关，CNT ）将s [off，off + cnt）复制到p。

九，字符串的缓冲区管理
字符串具有类似std :: vector的缓冲区管理界面。size
（）取得有效元素长度
max_size（）取得当前内存分配器能分配的有效空间
reserve（）为缓冲区预留空间
capacity（）取得缓冲区的容量
resize（）重设串的长度，可以为其指定初始值

十，定义输入迭代器的尾端
向istream_iterator传递输入流对象以创建输入迭代器，输入迭代器持有输入流对象的指针，默认创建和读取流失败的情况下该指针被设置为0.并且在实现输入迭代器间的运算符==相等运算时，进行持有的流对象指针的相等比较，这样，默认创建的输入迭代器将用于匹配输入流的结束。

当输入流读取失败，用户执行if，while条件判断时，实际上先于判断值转换成void *类型，或者根据运算符！运算符的返回结果，对输入流重载运算符void *和operator！运算符，可以定义输入流在布尔表达式中的行为，使得当流读取失败的情况下，输入迭代器可以通过布尔表达式来确认，而不是显式访问失败（）成员函数。
转：HTTP ：//www.jb51.net/article/37410.htm

标准Ç字符和字符串

ATOF语法：

  #include <stdlib.h>
  double atof( const char *str );

功能：将字符串str转换成一个双精度数值并返回结果。参数str必须以有效数字开头，但是允许以“E”或“e”除外的任意非数字字符结尾。例如：

x = atof( "42.0is_the_answer" );

x的值为42.0。
相关主题：atoi（）和atol（）。
ATOI语法：

  #include <stdlib.h>
  int atoi( const char *str );

功能：将字符串str转换成一个整数并返回结果。参数str以数字开头，当函数从str中读到非数字字符则结束转换并将结果返回。例如，

i = atoi( "512.035" );

我的值为512。

相关主题：atof（）和atol（）。

蒂语法：

  #include <stdlib.h>
  long atol( const char *str );

功能：将字符串转换成长整型数并返回结果函数会扫描参数海峡字符串，跳过前面的空格字符，直到遇上数字或正负符号才开始做转换，而再遇到非数字或字符串结束时才结束转换，并将结果返回。例如，

x = atol( "1024.0001" );

X的值为1024L。

相关主题：atof（）和atoi（）。

字符isalnum语法：

  #include <ctype.h>
  int isalnum( int ch );

功能：如果参数是数字或字母字符，函数返回非零值，否则返回零值。

  char c;
  scanf( "%c", &c );
  if( isalnum(c) )
  printf( "You entered the alphanumeric character %c\n", c );

相关主题：isalpha（），iscntrl（），isdigit（），isgraph（），isprint（），ispunct（）和isspace（）。

因而isalpha语法：

#include <ctype.h>
  int isalpha( int ch );

功能：如果参数是字母字符，函数返回非零值，否则返回零值。

    char c;
    scanf( "%c", &c );
    if( isalpha(c) )
    printf( "You entered a letter of the alphabet\n" );

相关主题：isalnum（），iscntrl（），isdigit（），isgraph（），isprint（），ispunct（）和isspace（）。

iscntrl判断语法：

  #include <ctype.h>
  int iscntrl( int ch );

功能：如果参数是控制字符（0和0x1F的之间的字符，或者等于0x7F的）函数返回非零值，否则返回零值。

相关主题：isalnum（），isalpha（），isdigit（），isgraph（），isprint（），ispunct（）和isspace（）。

ISDIGIT语法：

  #include <ctype.h>
  int isdigit( int ch );

功能：如果参数是0到9之间的数字字符，函数返回非零值，否则返回零值。

char c;


scanf( "%c", &c );


if( isdigit(c) )


printf( "You entered the digit %c\n", c );

相关主题：isalnum（），isalpha（），iscntrl（），isgraph（），isprint（），ispunct（）和isspace（）。

isgraph语法：

  #include <ctype.h>
  int isgraph( int ch );

功能：如果参数是除空格外的可打印字符（可见的字符），函数返回非零值，否则返回零值。

相关主题：isalnum（），isalpha（），iscntrl（），isdigit（），isprint（），ispunct（）和isspace（）。

islower判断语法：

  #include <ctype.h>
  int islower( int ch );

功能：如果参数是小写字母字符，函数返回非零值，否则返回零值。