一篇文章解析所有C语言里字符串的操作

####@函数名称: 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§ 取字符串长度
###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§ 字符串转换到 int 整型
###atof§ 字符串转换到 double 符点数
###atol§ 字符串转换到 long 整型

##3）字符检查
###isalpha() 检查是否为字母字符
###isupper() 检查是否为大写字母字符
###islower() 检查是否为小写字母字符
###isdigit() 检查是否为数字
###isxdigit() 检查是否为十六进制数字表示的有效字符
###isspace() 检查是否为空格类型字符
###iscntrl() 检查是否为控制字符
###ispunct() 检查是否为标点符号
###isalnum() 检查是否为字母和数字
###isprint() 检查是否是可打印字符
###isgraph() 检查是否是图形字符，等效于 isalnum() | ispunct()

##4）函数原型
原型：strcpy(char destination[], const char source[]);
功能：将字符串source拷贝到字符串destination中
例程：

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

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

strncpy函数应用举例
原型：strncpy(char destination[], const char source[], int numchars);
功能：将字符串source中前numchars个字符拷贝到字符串destination中
例程：

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

运行结果：Comnghua
注意：字符串source中前numchars个字符将覆盖掉字符串destination中前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; 
}

运行结果：Tsinghua Computer

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

原型：strncat(char target[], const char source[], int numchars);
功能：将字符串source的前numchars个字符接到字符串target的后面
例程：

#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 secondstring);
功能：比较两个字符串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; 
}

运行结果是:Buffer 2 is less than buffer 1
Buffer 2 is greater than buffer 3

原型：strlen( const char string[] );
功能：统计字符串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; 
}

运行结果The length of the string is x (x为你输入的字符总数字)

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

void *memset(void *dest, int c, size_t count);
将dest前面count个字符置为字符c. 返回dest的值.

void *memmove(void *dest, const void *src, size_t count);
从src复制count字节的字符到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);
将string中所有小写字母替换成相应的大写字母, 其它字符保持不变. 返回调整后的字符串的指针.

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

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

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

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

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. 如果count大于源串长度, 则会用源串的长度值替换count值. 得到的新串后面会自动加上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);
将string串的所有字符设置为字符c, 遇到NULL结束符停止. 函数返回内容调整后的string指针.

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

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大于string2.

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, 表示string1的子串小于string2的子串;
返回值为0, 表示string1的子串等于string2的子串;
返回值> 0, 表示string1的子串大于string2的子串.

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

char *strtok(char *strToken, const char *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 字符的过程，实现 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）迭代器 + 分配器

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

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

(basic_string<_Elem, _Traits, _Alloc>::size_type)(-1);

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

五、比较字符串
允许的比较对象
1）compare(s2) 其他同类型字符串
2）compare§ C 风格字符串
3）compare(off, cnt, s2) [off, off + cnt) 同 s2 执行比较
4）compare(off, cnt, s2, off2, cnt2) [off, off + cnt) 同 s2 [off2, cnt2) 执行比较
5）compare(off, cnt, p) [off, off + 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, )
4、append(p, cnt) 追加字符串 [p, p + cnt)
5、append(n, c) 填充 n * c
6、append(InF, InL) 追加输入流 [InF, InL)

4）insert() 插入
1、insert(off, s2) 插入字符串
2、insert(off, s2, off2, cnt2) 插入字符串 s [off2, off2 + cnt2)
3、insert(off, p) 插入字符串 [p, )
4、insert(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、find(p, off) 在 s [off, npos) 中查找 [p, )
4、find(s2, off) 在 s [off, npos) 中查找 s2

2）find() 的变种
1、rfind() 具有 find() 的输入形式，反序查找
2、find_first_of() 具有 find() 的输入形式，返回第一个匹配的索引
3、find_last_of() 具有 find() 的输入形式，返回倒数第一个匹配的索引
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、replace(InF, InL, s2) 将 [InF, InL) 替换成 s2
7、replace(InF, InL, p) 将 [InF, InL) 替换成 [p, )
8、replace(InF, InL, p, cnt) 将 [InF, InL) 替换成 [p, p + cnt)
9、replace(InF, InL, n, c) 将 [InF, InL) 替换成 n * c
10、replace(InF, InL, InF2, InL2) 将 [InF, InL) 替换成 [InF2, InL2)

4）erase() 删除
1、erase(off, cnt) 从字符串 s 中删除 s [off, off + cnt)
2、erase(iter) 从字符串 s 中删除 *iter
3、erase(ItF, ItL) 从字符串 s 中删除 [ItF, ItL)

八、取出字符串
1）取得 C 风格字符串
c_str() 返回常量类型的 C 风格字符串指针，copy(ptr, cnt, off = 0) 则将指定大小的字符串复制到特定指针。data() 在 Visual C++ 7.1 中仅仅调用了 c_str() 实现。
2）取得子字符串
substr(off, cnt) 取得 s [off, off + cnt) 的副本。
3）复制子字符串
copy(p, off, cnt) 将 s [off, off + cnt) 复制到 p。

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

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

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

标准c字符和字符串

atof语法:

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

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

x = atof( "42.0is_the_answer" );

x的值为42.0.
相关主题: atoi() and atol().
atoi语法:

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

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

i = atoi( "512.035" );

i 的值为 512.

相关主题: atof() and atol().

atol语法:

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

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

x = atol( "1024.0001" );

x的值为1024L.

相关主题: atof() and 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(), and 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(), and isspace().

iscntrl语法:

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

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

相关主题: isalnum(), isalpha(), isdigit(), isgraph(), isprint(), ispunct(), and 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(), and isspace().

isgraph语法:

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

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

相关主题: isalnum(), isalpha(), iscntrl(), isdigit(), isprint(), ispunct(), and isspace().

islower语法:

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

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

相关主题: isupper()

isprint语法:

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

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

相关主题: isalnum(), isalpha(), iscntrl(), isdigit(), isgraph(), ispunct(), and isspace().

ispunct语法:

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

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

相关主题: isalnum(), isalpha(), iscntrl(), isdigit(), isgraph(), isprint(), and isspace().

isspace语法:

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

功能：如果参数是空格类字符（即：单空格，制表符，垂直制表符，满页符，回车符，新行符），函数返回非零值，否则返回零值。

相关主题: isalnum(), isalpha(), iscntrl(), isdigit(), isgraph(), and ispunct().

isupper语法:

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

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

相关主题: tolower()

isxdigit语法:

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

功能：如果参数是十六进制数字字符（即：A-F, a-f, 0-9），函数返回非零值，否则返回零值。

相关主题: isalnum(), isalpha(), iscntrl(), isdigit(), isgraph(), ispunct(), and isspace().

memchr语法:

  #include <string.h>
  void *memchr( const void *buffer, int ch, size_t count );

功能：函数在buffer指向的数组的count个字符的字符串里查找ch 首次出现的位置。返回一个指针，指向ch 在字符串中首次出现的位置, 如果ch没有在字符串中找到，返回NULL。例如:

char names[] = "Alan Bob Chris X Dave";


if( memchr(names,'X',strlen(names)) == NULL )


  printf( "Didn't find an X\n" );


else


  printf( "Found an X\n" );

相关主题: memcpy() and strstr().

memcmp语法:

  #include <string.h>
  int memcmp( const void *buffer1, const void *buffer2, size_t count );

功能：函数比较buffer1 和 buffer2的前count 个字符。返回值如下:

Value

解释

less than 0

buffer1 is less than buffer2

equal to 0

buffer1 is equal to buffer2

greater than 0

buffer1 is greater than buffer2

相关主题: memchr(), memcpy(), and strcmp().

memcpy语法:

  #include <string.h>
  void *memcpy( void *to, const void *from, size_t count );
 

功能：函数从from中复制count 个字符到to中，并返回to指针。 如果to 和 from 重叠，则函数行为不确定。

相关主题: memmove().

memmove语法:

  #include <string.h>
  void *memmove( void *to, const void *from, size_t count );
 

功能: 与mencpy相同，不同的是当to 和 from 重叠，函数正常仍能工作。

相关主题: memcpy().

memset语法:

  #include <string.h>
  void *memset( void *buffer, int ch, size_t count );

功能: 函数拷贝ch 到buffer 从头开始的count 个字符里, 并返回buffer指针。 memset() 可以应用在将一段内存初始化为某个值。例如：

memset( the_array, '\0', sizeof(the_array) );

这是将一个数组的所以分量设置成零的很便捷的方法。

相关主题: memcmp(), memcpy(), and memmove().

strcat语法:

 

  #include <string.h>
  char *strcat( char *str1, const char *str2 );

功能：函数将字符串str2 连接到str1的末端，并返回指针str1. 例如：

printf( "Enter your name: " );


scanf( "%s", name );


title = strcat( name, " the Great" );


printf( "Hello, %s\n", title );

相关主题: strchr(), strcmp(), and strcpy().

strchr语法:

  #include <string.h>
  char *strchr( const char *str, int ch );

功能：函数返回一个指向str 中ch 首次出现的位置，当没有在str 中找ch到返回NULL。

相关主题: strpbrk(), strspn(), strstr(), and strtok().

strcmp语法:

  #include <string.h>
  int strcmp( const char *str1, const char *str2 );

功能：比较字符串str1 and str2, 返回值如下:

返回值

解释

less than 0

str1 is less than str2

equal to 0

str1 is equal to str2

greater than 0

str1 is greater than str2

例如:

printf( "Enter your name: " );


scanf( "%s", name );


if( strcmp( name, "Mary" ) == 0 )


  printf( "Hello, Dr. Mary!\n" );

相关主题: memcmp(), strchr(), strcpy(), and strncmp().

strcoll语法:

  #include <string.h>
  int strcoll( const char *str1, const char *str2 );

功能：比较字符串str1 和 str2, 很象strcmp. 但是, strcoll() 使用在目前环境中由setlocale()设定的次序进行比较。

strcpy语法:

  #include <string.h>
  char *strcpy( char *to, const char *from );

功能：复制字符串from 中的字符到字符串to，包括空值结束符。返回值为指针to。

相关主题: memcpy(), strchr(), strcmp(), strncmp(), and strncpy().

strcspn语法:

  #include <string.h>
  size_t strcspn( const char *str1, const char *str2 );

功能：函数返回str1 开头连续n个字符都不含字符串str2内字符的字符数。

相关主题: strrchr(), strpbrk(), strstr(), and strtok().

strerror语法:

 

  #include <string.h>
  char *strerror( int num );

功能：函数返回一个被定义的与某错误代码相关的错误信息。

strlen语法:

  #include <string.h>
  size_t strlen( char *str );

功能：函数返回字符串str 的长度( 即空值结束符之前字符数目)。

相关主题: memcpy(), strchr(), strcmp(), and strncmp().

strncat语法:

 

  #include <string.h>
  char *strncat( char *str1, const char *str2, size_t count );

功能：将字符串from 中至多count个字符连接到字符串to中，追加空值结束符。返回处理完成的字符串。

相关主题: strcat(), strnchr(), strncmp(), and strncpy().

strncmp语法:

  #include <string.h>
  int strncmp( const char *str1, const char *str2, size_t count );

功能：比较字符串str1 和 str2中至多count个字符。返回值如下：

返回值

解释

less than 0

str1 is less than str2

equal to 0

str1 is equal to str2

greater than 0

str1 is greater than str2

如果参数中任一字符串长度小于count, 那么当比较到第一个空值结束符时，就结束处理。

相关主题: strcmp(), strnchr(), and strncpy().

strncpy语法:

  #include <string.h>
  char *strncpy( char *to, const char *from, size_t count );

功能：将字符串from 中至多count个字符复制到字符串to中。如果字符串from 的长度小于count，其余部分用’\0’填补。返回处理完成的字符串。

相关主题: memcpy(), strchr(), strncat(), and strncmp().

strpbrk语法:

  #include <string.h>
  char *strpbrk( const char *str1, const char *str2 );

功能：函数返回一个指针，它指向字符串str2中任意字符在字符串str1 首次出现的位置，如果不存在返回NULL。

相关主题: strspn(), strrchr(), strstr(), and strtok().

strrchr语法:

  #include <string.h>
  char *strrchr( const char *str, int ch );

功能：函数返回一个指针，它指向字符ch 在字符串str末次出现的位置，如果匹配失败，返回NULL。

相关主题: strpbrk(), strspn(), strstr(), strtok(),

strspn语法:

  #include <string.h>
  size_t strspn( const char *str1, const char *str2 );

功能：函数返回字符串str1中第一个不包含于字符串str2的字符的索引。

相关主题: strpbrk(), strrchr(), strstr(), strtok(),

strstr语法:

  #include <string.h>
  char *strstr( const char *str1, const char *str2 );

功能：函数返回一个指针，它指向字符串str2 首次出现于字符串str1中的位置，如果没有找到，返回NULL。

相关主题: strchr(), strcspn(), strpbrk(), strspn(), strtok(), strrchr(),

strtod语法:

  #include <stdlib.h>
  double strtod( const char *start, char **end );

功能：函数返回带符号的字符串start所表示的浮点型数。字符串end 指向所表示的浮点型数之后的部分。如果溢出发生，返回HUGE_VAL或 -HUGE_VAL。

相关主题: atof()

strtok语法:

  #include <string.h>
  char *strtok( char *str1, const char *str2 );

功能：函数返回字符串str1中紧接“标记”的部分的指针, 字符串str2是作为标记的分隔符。如果分隔标记没有找到，函数返回NULL。为了将字符串转换成标记，第一次调用str1 指向作为标记的分隔符。之后所以的调用str1 都应为NULL。

例如:
char str[] = “now # is the time for all # good men to come to the # aid of their country”;

char delims[] = "#";

char *result = NULL;

result = strtok( str, delims );

while( result != NULL ) {


   printf( "result is \"%s\"\n", result );


    result = strtok( NULL, delims );


}

以上代码的运行结果是：

result is "now "


result is " is the time for all "


result is " good men to come to the "


result is " aid of their country"

相关主题: strchr(), strcspn(), strpbrk(), strrchr(), and strspn().

strtol语法:

  #include <stdlib.h>
  long strtol( const char *start, char **end, int base );

功能：函数返回带符号的字符串start所表示的长整型数。参数base代表采用的进制方式。指针end 指向start所表示的整型数之后的部分。如果返回值无法用长整型表示，函数则返回LONG_MAX或LONG_MIN. 错误发生时，返回零。

相关主题: atol().

strtoul语法:

  #include <stdlib.h>
  unsigned long strtoul( const char *start, char **end, int base );

功能：函数基本等同 strtol(), 不同的是，它不仅可以返回长整型数，而且可以返回无符号的长整型数。

相关主题: strtol()

strxfrm语法:

 

  #include <string.h>
  size_t strxfrm( char *str1, const char *str2, size_t num );

功能：函数将字符串str2 的前num 个字符存储到字符串str1中。如果strcoll() 处理字符串str1 和旧的字符串str2, 返回值和strcmp()的处理结果一样。

相关主题: strcmp(), strcoll(),

tolower 语法:

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

功能：函数字符ch的小写形式。

相关主题: toupper(),

toupper语法:

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

功能：函数字符ch的大写形式。

相关主题: tolower(),

转：http://www.cnblogs.com/minotmin/p/3320699.html

1、字符数组的定义与初始化

字符数组的初始化，最容易理解的方式就是逐个字符赋给数组中各元素。

char str[10]={ ‘I’,’ ‘,‘a’,‘m’,’ ',‘h’,‘a’,‘p’,‘p’,‘y’};

即把10个字符分别赋给str[0]到str[9]10个元素

如果花括号中提供的字符个数大于数组长度，则按语法错误处理；若小于数组长度，则只将这些字符数组中前面那些元素，其余的元素自动定为空字符（即 ‘\0’ )。

2、字符数组与字符串

在c语言中，将字符串作为字符数组来处理。（c++中不是）

在实际应用中人们关心的是有效字符串的长度而不是字符数组的长度，例如，定义一个字符数组长度为100，而实际有效字符只有40个，为了测定字符串的实际长度，C语言规定了一个“字符串结束标志”，以字符’\0’代表。如果有一个字符串，其中第10个字符为’\0’，则此字符串的有效字符为9个。也就是说，在遇到第一个字符’\0’时，表示字符串结束，由它前面的字符组成字符串。

系统对字符串常量也自动加一个’\0’作为结束符。例如"C Program”共有9个字符，但在内存中占10个字节，最后一个字节’\0’是系统自动加上的。（通过sizeof()函数可验证）

有了结束标志’\0’后，字符数组的长度就显得不那么重要了，在程序中往往依靠检测’\0’的位置来判定字符串是否结束，而不是根据数组的长度来决定字符串长度。当然，在定义字符数组时应估计实际字符串长度，保证数组长度始终大于字符串实际长度。（在实际字符串定义中，常常并不指定数组长度，如char str[ ]）

说明：’\n’代表ASCII码为0的字符，从ASCII码表中可以查到ASCII码为0的字符不是一个可以显示的字符，而是一个“空操作符”，即它什么也不干。用它来作为字符串结束标志不会产生附加的操作或增加有效字符，只起一个供辨别的标志。

对C语言处理字符串的方法由以上的了解后，再对字符数组初始化的方法补充一种方法——即可以用字符串常量来初始化字符数组：

char str[ ]={“I am happy”}; 可以省略花括号，如下所示

char str[ ]=“I am happy”;

注意：上述这种字符数组的整体赋值只能在字符数组初始化时使用，不能用于字符数组的赋值，字符数组的赋值只能对其元素一一赋值，下面的赋值方法是错误的

         char str[ ];

         str="I am happy";

不是用单个字符作为初值，而是用一个字符串（注意：字符串的两端是用双引号“”而不是单引号‘’括起来的）作为初值。显然，这种方法更直观方便。（注意：数组str的长度不是10，而是11，这点请务必记住，因为字符串常量"I am happy"的最后由系统自动加上一个’\0’）
因此，上面的初始化与下面的初始化等价

char str[ ]={‘I’,’ ‘,‘a’,‘m’,’ ‘,‘h’,‘a’,‘p’,‘p’,‘y’,’\0’};

而不与下面的等价

char str[ ]={‘I’,’ ‘,‘a’,‘m’,’ ',‘h’,‘a’,‘p’,‘p’,‘y’};

前者的长度是11，后者的长度是10.

说明：字符数组并不要求它的最后一个字符为’\0’，甚至可以不包含’\0’，向下面这样写是完全合法的。

char str[5]={‘C’,‘h’,‘i’,‘n’,‘a’};

++++++++

可见，用两种不同方法初始化字符数组后得到的数组长度是不同的。

#include <stdio.h>

void main(void)
{
char c1[]={'I',' ','a','m',' ','h','a','p','p','y'};
char c2[]="I am happy";
int i1=sizeof(c1);
int i2=sizeof(c2);
printf("%d\n",i1);
printf("%d\n",i2);

}

结果：10 11

3、字符串的表示形式

在C语言中，可以用两种方法表示和存放字符串：

（1）用字符数组存放一个字符串

      char str[ ]="I love China";

（2）用字符指针指向一个字符串

      char* str="I love China";

对于第二种表示方法，有人认为str是一个字符串变量，以为定义时把字符串常量"I love China"直接赋给该字符串变量，这是不对的。

C语言对字符串常量是按字符数组处理的，在内存中开辟了一个字符数组用来存放字符串常量，程序在定义字符串指针变量str时只是把字符串首地址（即存放字符串的字符数组的首地址）赋给str。

两种表示方式的字符串输出都用

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

%s表示输出一个字符串，给出字符指针变量名str（对于第一种表示方法，字符数组名即是字符数组的首地址，与第二种中的指针意义是一致的），则系统先输出它所指向的一个字符数据，然后自动使str自动加1，使之指向下一个字符…，如此，直到遇到字符串结束标识符 " \0 "。

4、对使用字符指针变量和字符数组两种方法表示字符串的讨论

虽然用字符数组和字符指针变量都能实现字符串的存储和运算，但它们二者之间是有区别的，不应混为一谈。

4.1、字符数组由若干个元素组成，每个元素放一个字符；而字符指针变量中存放的是地址（字符串/字符数组的首地址），绝不是将字符串放到字符指针变量中（是字符串首地址）

4.2、赋值方式：

     对字符数组只能对各个元素赋值，不能用以下方法对字符数组赋值

     char str[14];

     str="I love China";     （但在字符数组初始化时可以，即char str[14]="I love China";）

     而对字符指针变量，采用下面方法赋值：

      char* a;

      a="I love China";

      或者是 char* a="I love China";       都可以

4.3、对字符指针变量赋初值（初始化）：

     char* a="I love China";      

等价于：

       char* a;

       a="I love China";

而对于字符数组的初始化

      char str[14]="I love China";

不能等价于：

     char str[14];

     str="I love China"; （这种不是初始化，而是赋值，而对数组这样赋值是不对的）

4.4、如果定义了一个字符数组，那么它有确定的内存地址；而定义一个字符指针变量时，它并未指向某个确定的字符数据，并且可以多次赋值。

5、字符串处理函数
5.1

char *strcat(char *str1,const char *2 );

char *strcat(char *strDestination,const char *strSource );

功能：函数将字符串str2 连接到str1的末端，并返回指针str1

注：连接前两个字符串的后面都有一个’ \0 '，连接时将字符串1后面的 ’ \0 ‘去掉，只在新串最后保留一个 ’ \0 ‘

5.2

char *strcpy(char *str1,const char *2 );

char *strcpy(char *strDestination,const char *strSource );

功能：复制字符串strSource中的字符到字符串strDestination，包括空值结束符。返回值为指针strDestination。

注：1、“字符数组1”必须写成数组名形式，“字符串2"可以是字符数组名，也可以是一个字符串常量

    2、复制时连同字符串后面的 ' \0 ' 一起复制到数组1中

    3、不能用赋值语句直接将一个字符串常量或者字符数组直接赋给一个字符数组（同普通变量数组是一样的），而只能用strcpy函数处理。

    4、可以用strcpy函数将字符串2中的前若干个字符复制到字符数组1中去。