string.h函数库详解

string.h函数总结
 
以下的函数使用时 都是入口参数  我们修改相应的入口参数进行试验
1     #ifndef __STRING_NO_EXPORTS
      using ::std::size_t;
      using ::std::memcpy;//xtern void *memcpy(void *dest, void *src, unsigned int count);
//  功能：由src所指内存区域复制count个字节到dest所指内存区域
      using ::std::memmove;//			memmove() 用来复制内存内容，其原型为：
//    void * memmove(void *dest, const void *src, size_t num);
//memmove() 与 memcpy() 类似都是用来复制 src 所指的内存内容前 num 个字节到 dest 所指的地址上。
//不同的是，memmove() 更为灵活，
//当src 和 dest 所指的内存区域重叠时，memmove() 仍然可以正确的处理，不过执行效率上会比使用 memcpy() 略慢些。
 
 
      using ::std::strcpy;// char *strcpy(char* dest, const char *src); 拷贝一个字符串到另一个
//把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间
//.src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。返回指向dest的指针
      using ::std::strncpy;//char *?strncpy(char *dest, char *src,size_t num);
//复制src中的内容（字符，数字、汉字....）到dest，复制多少由num的值决定，
//返回指向dest的指针。如果遇到null字符（'\0'），且还没有到num个字符时，就用（num - n）
//（n是遇到null字符前已经有的非null字符个数）个null字符附加到destination。
     using ::std::strcat;//char *strcat(char *dest,char *src);字符串拼接函数
//把src所指字符串添加到dest结尾处(覆盖dest结尾处的'\0')并添加'\0'。
//src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。返回指向dest的指针。
      using ::std::strncat;//char *strncat(char *dest,char *src,int n);
//把src所指字符串的前n个字符添加到dest结尾处（覆盖dest结尾处的'\0'）
//并添加'\0'。src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。返回指向dest的指针。
      using ::std::memcmp;		
//基本原型 int memcmp(const void *buf1, const void *buf2, unsigned int count);
//主要功能
//比较内存区域buf1和buf2的前count个字节。
//返回值
//当buf1
//当buf1=buf2时，返回值=0
//当buf1>buf2时，返回值>0
      using ::std::strcmp;//int strcmp(const char *s1,const char * s2);
//比较字符串s1和s2。
//当s1
//当s1==s2时，返回值=0
//当s1>s2时，返回值>0
//即：两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇'\0'为止。
      using ::std::strncmp;//int?strncmp(char *str1, char *str2, int maxlen);
//此函数功能即比较字符串str1和str2的前maxlen个字符。
//如果前maxlen字节完全相等，返回值就=0；
//在前maxlen字节比较过程中，如果出现str1[n]与str2[n]不等，则返回（str1[n]-str2[n]）。
 
      using ::std::strcasecmp;//			int?strcasecmp?(const char *s1, const char *s2);
//strcasecmp()用来比较参数s1和s2字符串，比较时会自动忽略大小写的差异。
//若参数s1和s2字符串相等则返回0。
//s1大于s2则返回大于0 的值。
//s1 小于s2 则返回小于0的值。
 
      using ::std::strncasecmp;
//int?strncasecmp(const char *s1, const char *s2, size_t n)
//strncasecmp()用来比较参数s1和s2字符串前n个字符，比较时会自动忽略大小写的差异,
//若参数s1和s2字符串相同则返回0?
//s1若大于s2则返回大于0的值
//s1若小于s2则返回小于0的值.
		
      using ::std::strcoll;
//	以下是与strcoll() 函数的声明。
//int strcoll(const char *str1, const char *str2)	
//			str1?-- 这是第一个要比较的字符串。		
//			str2?-- 这是第二个进行比较的字符串。
//	这个函数的返回值如下：	
//			如果返回值<0，则表明str1小于str2		
//			如果返回值，如果> 0，则表明str2?小于 str1		
//			如果返回值= 0，则表明str1?等于str2
			//默认情况下(LC_COLLATE为"POSIX"或"C")和strcmp一样根据ASCII比较字符串大小，这个时候是没有区别的。
			//对于设置了LC_COLLATE语言环境的情况下，则根据LC_COLLATE设置的语言排序方式进行比较。例如：汉字，根据拼音进行比较。
			//2、strcmp是比较两个字符串的大小,两个字符串相同时返回0,第一个字符串大于第二个字符串时返回一个正值,否则返回负值。
			//比较两个字符串的算法是:逐个比较两个串中对应的字符，字符大小按照ASCII码值确定，从左向右比较，
			//如果遇到不同字符，所遇第一对不同字符的大小关系就确定了两个字符串的大小关系
			//，如果未遇到不同字符而某个字符串首先结束，那么这个字符串是较小的，否则两个字符串相等。
      using ::std::memchr;
//			 库函数 void *memchr(const void *str, int c, size_t n) 
//在参数 str 所指向的字符串的前 n 个字节中搜索第一次出现字符 c（一个无符号字符）的位置。
//声明
//下面是 memchr() 函数的声明。
//void *memchr(const void *str, int c, size_t n)
//参数
//str -- 指向要执行搜索的内存块。
//c -- 以 int 形式传递的值，但是函数在每次字节搜索时是使用该值的无符号字符形式。
//n -- 要被分析的字节数。
//返回值
//该函数返回一个指向匹配字节的指针，如果在给定的内存区域未出现字符，则返回 NULL。
//实例
//下面的实例演示了 memchr() 函数的用法。
//实例
//#include 
//#include 
// 
//int main ()
//{
//   const char str[] = "http://www.runoob.com";
//   const char ch = '.';
//   char *ret;
// 
//   ret = (char*)memchr(str, ch, strlen(str));
// 
//   printf("|%c| 之后的字符串是 - |%s|\n", ch, ret);
// 
//   return(0);
//}
			
      using ::std::strchr;//char *strchr(char *str,char c);  在一个串中查找给定字符的第一个匹配之处
      using ::std::strcspn;
//			C 库函数 size_t strcspn(const char *str1, const char *str2) 检索字符串 str1 开头连续有几个字符都不含字符串 str2 中的字符。
//声明
//下面是 strcspn() 函数的声明。
//size_t strcspn(const char *str1, const char *str2)
      using ::std::strpbrk;
//			C 库函数 char *strpbrk(const char *str1, const char *str2) 
//检索字符串 str1 中第一个匹配字符串 str2 中字符的字符，不包含空结束字符。
//也就是说，依次检验字符串 str1 中的字符，当被检验字符在字符串 str2 中也包含时，则停止检验，并返回该字符位置。
//声明
//下面是 strpbrk() 函数的声明。
//char *strpbrk(const char *str1, const char *str2)
//参数
//str1 -- 要被检索的 C 字符串。
//str2 -- 该字符串包含了要在 str1 中进行匹配的字符列表。
//返回值
//该函数返回 str1 中第一个匹配字符串 str2 中字符的字符数，如果未找到字符则返回 NULL。
//实例
//下面的实例演示了 strpbrk() 函数的用法。
//#include 
//#include 
//int main ()
//{
//   const char str1[] = "abcde2fghi3jk4l";
//   const char str2[] = "34";
//   char *ret;
 
//   ret = strpbrk(str1, str2);
//   if(ret) 
//   {
//      printf("第一个匹配的字符是： %c\n", *ret);
//   }
//   else 
//   {
//      printf("未找到字符");
//   }
//   
//   return(0);
//}
//让我们编译并运行上面的程序，这将产生以下结果：
//第一个匹配的字符是： 3
			
      using ::std::strrchr;
//			C 库函数 char *strrchr(const char *str, int c) 在参数 str 所指向的字符串中搜索最后一次出现字符 c（一个无符号字符）的位置。
//声明
//下面是 strrchr() 函数的声明。
//char *strrchr(const char *str, int c)
//参数
//str -- C 字符串。
//c -- 要搜索的字符。以 int 形式传递，但是最终会转换回 char 形式。
//返回值
//该函数返回 str 中最后一次出现字符 c 的位置。如果未找到该值，则函数返回一个空指针。
//实例
//下面的实例演示了 strrchr() 函数的用法。
//实例
//#include 
//#include 
// 
//int main ()
//{
//   int len;
//   const char str[] = "https://www.runoob.com";
//   const char ch = '.';
//   char *ret;
// 
//   ret = strrchr(str, ch);
// 
//   printf("|%c| 之后的字符串是 - |%s|\n", ch, ret);
//   
//   return(0);
//}
//让我们编译并运行上面的程序，这将产生以下结果：
//|.| 之后的字符串是 - |.com|
      using ::std::strspn;
//			C 库函数 size_t strspn(const char *str1, const char *str2) 检索字符串 str1 中第一个不在字符串 str2 中出现的字符下标。
//声明
//下面是 strspn() 函数的声明。
//size_t strspn(const char *str1, const char *str2)
//参数
//str1 -- 要被检索的 C 字符串。
//str2 -- 该字符串包含了要在 str1 中进行匹配的字符列表。
//返回值
//该函数返回 str1 中第一个不在字符串 str2 中出现的字符下标。
//实例
//下面的实例演示了 strspn() 函数的用法。
//#include 
//#include 
//int main ()
//{
//   int len;
//   const char str1[] = "ABCDEFG019874";
//   const char str2[] = "ABCD";
 
//   len = strspn(str1, str2);
 
//   printf("初始段匹配长度 %d\n", len );
//   
//   return(0);
//}
//让我们编译并运行上面的程序，这将产生以下结果：
//初始段匹配长度 4
			
      using ::std::strstr;
//			C 库函数 char *strstr(const char *haystack, const char *needle) 在字符串 haystack 中查找第一次出现字符串 needle 的位置，不包含终止符 '\0'。
 
//声明
//下面是 strstr() 函数的声明。
 
//char *strstr(const char *haystack, const char *needle)
//参数
//haystack -- 要被检索的 C 字符串。
//needle -- 在 haystack 字符串内要搜索的小字符串。
//返回值
//该函数返回在 haystack 中第一次出现 needle 字符串的位置，如果未找到则返回 null。
 
//实例
//下面的实例演示了 strstr() 函数的用法。
 
//#include 
//#include 
 
 
//int main()
//{
//   const char haystack[20] = "RUNOOB";
//   const char needle[10] = "NOOB";
//   char *ret;
 
//   ret = strstr(haystack, needle);
 
//   printf("子字符串是： %s\n", ret);
//   
//   return(0);
//}
//让我们编译并运行上面的程序，这将产生以下结果：
 
//子字符串是： NOOB
			
      using ::std::strtok;
//			C 库函数 char *strtok(char *str, const char *delim) 分解字符串 str 为一组字符串，delim 为分隔符。
 
//声明
//下面是 strtok() 函数的声明。
 
//char *strtok(char *str, const char *delim)
//参数
//str -- 要被分解成一组小字符串的字符串。
//delim -- 包含分隔符的 C 字符串。
//返回值
//该函数返回被分解的第一个子字符串，如果没有可检索的字符串，则返回一个空指针。
 
//实例
//下面的实例演示了 strtok() 函数的用法。
 
//实例
//#include 
//#include 
// 
//int main () {
//   char str[80] = "This is - www.runoob.com - website";
//   const char s[2] = "-";
//   char *token;
//   
//   /* 获取第一个子字符串 */
//   token = strtok(str, s);
//   
//   /* 继续获取其他的子字符串 */
//   while( token != NULL ) {
//      printf( "%s\n", token );
//    
//      token = strtok(NULL, s);
//   }
//   
//   return(0);
//}
//让我们编译并运行上面的程序，这将产生以下结果：
 
//This is 
// www.runoob.com 
// website
#ifndef __STRICT_ANSI__
      using ::std::strtok_r;
#endif
      using ::std::_strtok_r;
      using ::std::memset;
//	void *memset(void *str, int c, size_t n) 复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符。
 
//声明
//下面是 memset() 函数的声明。
 
//void *memset(void *str, int c, size_t n)
//参数
//str -- 指向要填充的内存块。
//c -- 要被设置的值。该值以 int 形式传递，但是函数在填充内存块时是使用该值的无符号字符形式。
//n -- 要被设置为该值的字节数。
//返回值
//该值返回一个指向存储区 str 的指针。
 
//实例
//下面的实例演示了 memset() 函数的用法。
 
//#include 
//#include 
 
//int main ()
//{
//   char str[50];
 
//   strcpy(str,"This is string.h library function");
//   puts(str);
 
//   memset(str,'$',7);
//   puts(str);
//   
//   return(0);
//}
//让我们编译并运行上面的程序，这将产生以下结果：
 
//This is string.h library function
//$$$$$$$ string.h library function
      using ::std::strerror;
//			char *strerror(int errnum) 从内部数组中搜索错误号 errnum，并返回一个指向错误消息字符串的指针。strerror 生成的错误字符串取决于开发平台和编译器。
 
//声明
//下面是 strerror() 函数的声明。
 
//char *strerror(int errnum)
//参数
//errnum -- 错误号，通常是 errno。
//返回值
//该函数返回一个指向错误字符串的指针，该错误字符串描述了错误 errnum。
 
//实例
//下面的实例演示了 strerror() 函数的用法。
 
//#include 
//#include 
//#include 
 
//int main ()
//{
//   FILE *fp;
 
//   fp = fopen("file.txt","r");
//   if( fp == NULL ) 
//   {
//      printf("Error: %s\n", strerror(errno));
//   }
//   
//  return(0);
//}
//让我们编译并运行上面的程序，这将产生以下结果，因为我们尝试打开一个不存在的文件：
 
//Error: No such file or directory
      using ::std::strlen;
//			unsigned int strlen(char *s）;
//计算字符串s的（unsigned int型）长度，不包括'\0'在内.返回s的长度，不包括结束符NULL
      using ::std::strlcpy;
      using ::std::strlcat;
      using ::std::_membitcpybl;
      using ::std::_membitcpybb;
      using ::std::_membitcpyhl;
      using ::std::_membitcpyhb;
      using ::std::_membitcpywl;
      using ::std::_membitcpywb;
      using ::std::_membitmovebl;
      using ::std::_membitmovebb;
      using ::std::_membitmovehl;
      using ::std::_membitmovehb;
      using ::std::_membitmovewl;
      using ::std::_membitmovewb;
    #endif /* __STRING_NO_EXPORTS */
		
//		
//		1	void *memchr(const void *str, int c, size_t n)
//在参数 str 所指向的字符串的前 n 个字节中搜索第一次出现字符 c（一个无符号字符）的位置。
//2	int memcmp(const void *str1, const void *str2, size_t n)
//把 str1 和 str2 的前 n 个字节进行比较。
//3	void *memcpy(void *dest, const void *src, size_t n)
//从 src 复制 n 个字符到 dest。
//4	void *memmove(void *dest, const void *src, size_t n)
//另一个用于从 src 复制 n 个字符到 dest 的函数。
//5	void *memset(void *str, int c, size_t n)
//复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符。
//6	char *strcat(char *dest, const char *src)
//把 src 所指向的字符串追加到 dest 所指向的字符串的结尾。
//7	char *strncat(char *dest, const char *src, size_t n)
//把 src 所指向的字符串追加到 dest 所指向的字符串的结尾，直到 n 字符长度为止。
//8	char *strchr(const char *str, int c)
//在参数 str 所指向的字符串中搜索第一次出现字符 c（一个无符号字符）的位置。
//9	int strcmp(const char *str1, const char *str2)
//把 str1 所指向的字符串和 str2 所指向的字符串进行比较。
//10	int strncmp(const char *str1, const char *str2, size_t n)
//把 str1 和 str2 进行比较，最多比较前 n 个字节。
//11	int strcoll(const char *str1, const char *str2)
//把 str1 和 str2 进行比较，结果取决于 LC_COLLATE 的位置设置。
//12	char *strcpy(char *dest, const char *src)
//把 src 所指向的字符串复制到 dest。
//13	char *strncpy(char *dest, const char *src, size_t n)
//把 src 所指向的字符串复制到 dest，最多复制 n 个字符。
//14	size_t strcspn(const char *str1, const char *str2)
//检索字符串 str1 开头连续有几个字符都不含字符串 str2 中的字符。
//15	char *strerror(int errnum)
//从内部数组中搜索错误号 errnum，并返回一个指向错误消息字符串的指针。
//16	size_t strlen(const char *str)
//计算字符串 str 的长度，直到空结束字符，但不包括空结束字符。
//17	char *strpbrk(const char *str1, const char *str2)
//检索字符串 str1 中第一个匹配字符串 str2 中字符的字符，不包含空结束字符。也就是说，依次检验字符串 str1 中的字符，当被检验字符在字符串 str2 中也包含时，则停止检验，并返回该字符位置。
//18	char *strrchr(const char *str, int c)
//在参数 str 所指向的字符串中搜索最后一次出现字符 c（一个无符号字符）的位置。
//19	size_t strspn(const char *str1, const char *str2)
//检索字符串 str1 中第一个不在字符串 str2 中出现的字符下标。
//20	char *strstr(const char *haystack, const char *needle)
//在字符串 haystack 中查找第一次出现字符串 needle（不包含空结束字符）的位置。
//21	char *strtok(char *str, const char *delim)
//分解字符串 str 为一组字符串，delim 为分隔符。
//22	size_t strxfrm(char *dest, const char *src, size_t n)
//根据程序当前的区域选项中的 LC_COLLATE 来转换字符串 src 的前 n 个字符，并把它们放置在字符串 dest 中。
————————————————
版权声明：本文为CSDN博主「位文杰TOP」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_36958104/article/details/97246539