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<buf2时,返回值<0
//当buf1=buf2时,返回值=0
//当buf1>buf2时,返回值>0
      using ::std::strcmp;//int strcmp(const char *s1,const char * s2);
//比较字符串s1和s2。
//当s1<s2时,返回值<0
//当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 <stdio.h>
//#include <string.h>
// 
//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 <stdio.h>
//#include <string.h>
//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 <stdio.h>
//#include <string.h>
// 
//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 <stdio.h>
//#include <string.h>
//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 <stdio.h>
//#include <string.h>


//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 <string.h>
//#include <stdio.h>
// 
//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 <stdio.h>
//#include <string.h>

//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 <stdio.h>
//#include <string.h>
//#include <errno.h>

//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 中。

 

<think>好的,用户想了解string.h函数的作用。我需要先回忆一下C语言中的string.h头文件。 首先,string.h主要提供字符串处理相关的函数,比如复制、连接、比较等。还有内存操作函数,比如memcpymemset,虽然这些处理的是内存块,但通常也包含在这个头文件里。 接下来,我需要分清楚字符串操作和内存操作两大类。字符串操作包括strcpy、strcat、strcmp、strlen这些基本函数,每个的用途和注意事项需要解释清楚。比如strcpy可能存在缓冲区溢出的问题,这时候可以提到更安全的strncpy。 然后是内存操作函数,如memcpymemmove、memset、memcmp。需要指出memcpymemmove的区别,后者能处理重叠内存区域,而前者不能。 用户可能需要知道这些函数的基本用法和常见应用场景。比如strlen用于获取字符串长度,strcmp在排序时的比较作用,memset初始化内存块等。 还要注意安全性问题,比如strcat可能导致缓冲区溢出,应该建议使用strncat来限制长度,或者更安全的替代函数。 另外,可能提到一些不常见的函数,如strstr查找子串,strchr查找字符出现的位置,strtok分割字符串等,这些也是string.h的一部分。 需要组织这些内容,结构清晰,分点列出,每个函数简要说明作用和示例。同时要提醒用户使用时要注意的事项,比如确保目标缓冲区足够大,避免溢出。 最后,总结一下string.h的作用,强调它在处理字符串和内存操作时的重要性,帮助用户高效、安全地管理数据。</think>`string.h` 是 C 语言标准库中用于处理字符串和内存操作的头文件,包含了一系列常用函数。以下是其核心功能及常用函数的分类说明: --- ### **一、字符串操作函数** 1. **字符串复制** - `strcpy(dest, src)` 将 `src` 字符串复制到 `dest`,需确保 `dest` 空间足够(否则可能溢出)。 - `strncpy(dest, src, n)` 更安全的版本,最多复制 `n` 个字符。 **示例**: ```c char dest[10]; strcpy(dest, "hello"); // dest 内容变为 "hello" ``` 2. **字符串连接** - `strcat(dest, src)` 将 `src` 字符串追加到 `dest` 末尾,需保证 `dest` 缓冲区足够大。 - `strncat(dest, src, n)` 最多追加 `n` 个字符。 **示例**: ```c char dest[20] = "Hello"; strcat(dest, " World"); // dest 变为 "Hello World" ``` 3. **字符串比较** - `strcmp(s1, s2)` 比较两字符串: - 返回 `0` 表示相等; - 返回 `正数` 表示 `s1 > s2`; - 返回 `负数` 表示 `s1 < s2`。 - `strncmp(s1, s2, n)` 仅比较前 `n` 个字符。 4. **字符串长度** - `strlen(s)` 返回字符串长度(不包含结尾的 `\0`)。 **示例**: ```c int len = strlen("abc"); // len = 3 ``` 5. **查找子字符串** - `strstr(s, substr)` 返回 `s` 中第一次出现 `substr` 的地址,未找到则返回 `NULL`。 **示例**: ```c char *pos = strstr("hello world", "wo"); // pos 指向 "world" ``` --- ### **二、内存操作函数** 1. **内存复制** - `memcpy(dest, src, n)` 从 `src` 复制 `n` 字节到 `dest`,要求内存区域不重叠。 - `memmove(dest, src, n)` 安全处理重叠内存的复制。 **示例**: ```c int arr1[3] = {1, 2, 3}; int arr2[3]; memcpy(arr2, arr1, sizeof(arr1)); // arr2 变为 {1, 2, 3} ``` 2. **内存填充** - `memset(ptr, value, n)` 将 `ptr` 指向的内存的前 `n` 字节设为 `value`(通常用于初始化)。 **示例**: ```c char buffer[10]; memset(buffer, 0, sizeof(buffer)); // 全部初始化为 0 ``` 3. **内存比较** - `memcmp(ptr1, ptr2, n)` 比较两内存区域的前 `n` 字节,返回值类似 `strcmp()`。 --- ### **三、字符查找与分割** 1. **查找字符** - `strchr(s, c)` 返回 `s` 中首次出现字符 `c` 的地址。 - `strrchr(s, c)` 返回 `s` 中最后一次出现字符 `c` 的地址。 2. **字符串分割** - `strtok(s, delim)` 按分隔符 `delim` 分割字符串 `s`(线程不安全)。 - `strtok_r(s, delim, saveptr)` 线程安全版本(需特定编译器支持)。 **示例**: ```c char str[] = "apple,banana,cherry"; char *token = strtok(str, ","); // 第一次调用返回 "apple" ``` --- ### **四、注意事项** 1. **缓冲区溢出风险** `strcpy`、`strcat` 等函数可能引发溢出,建议使用 `strncpy`、`strncat` 或更安全的替代方案(如 `snprintf`)。 2. **字符串结尾符** 所有字符串必须以 `\0` 结尾,否则函数行为未定义。 3. **内存重叠问题** 使用 `memcpy` 时,若源和目标内存重叠,需改用 `memmove`。 --- ### **五、总结** `string.h` 提供了对字符串和内存块的高效操作,覆盖了复制、比较、连接、搜索等常见需求。合理使用这些函数能简化代码,但需注意安全性和边界条件。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值