C进阶--字符函数和字符串函数介绍

已于 2023-10-01 17:44:57 修改
阅读量178 收藏 2
点赞数 5
分类专栏： C语言 文章标签： c语言 开发语言
于 2023-10-01 17:39:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59293418/article/details/133454482
版权

✨ 更多细节参考 cplusplus.com/reference/cstring/

使用方式：

⭕ 求字符串长度

🖌   strlen

函数原型：

size_t strlen ( const char * str );

作用：

获取字符串长度

✨补充：
⭐字符串以  '\0' 作为结束标志， strlen 函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0' ) 。

⭐参数指向的字符串必须要以 '\0' 结束。
⭐注意函数的返回值为size_t ，是无符号的（ 易错 ）

strlen函数的使用

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

int main ()
{
  char buffer[256];
  printf ("Enter a sentence: ");
  gets (buffer);
  printf ("The sentence entered is %u characters long.\n",(unsigned)strlen(szInput));
  return 0;
}

运行结果：

strlen函数模拟实现

🔪 方法一：计数器

size_t my_strlen(const char* str)
{
	int count = 0;
	assert(str != NULL);
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

🔪 方法二：递归

size_t my_strlen(const char* str)
{
	if (*str == '\0')
		return 0;
	else
		return my_strlen(str + 1) + 1;
}

🔪 方法三：指针-指针

size_t my_strlen(const char* str)
{
	const char* p = str;
	while (*str != '\0')
		str++;
	return str - p;
}

⭕ 长度不受限制的字符串函数

🖌   strcpy

函数原型：

char * strcpy ( char * destination, const char * source );

函数功能：

将源指向的 C 字符串复制到目标指向的数组中

函数使用：

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

int main ()
{
  char str1[]="Sample string";
  char str2[40];
  char str3[40];
  strcpy (str2,str1);
  strcpy (str3,"copy successful");
  printf ("str1: %s\nstr2: %s\nstr3: %s\n",str1,str2,str3);
  return 0;
}
✨有源字符串必须以 '\0' 结束。
✨会将源字符串中的 '\0' 拷贝到目标空间。
✨目标空间必须足够大，以确保能存放源字符串。
✨目标空间必须可变。

✨strcpy函数返回的是目标空间的起始地址
✨strcpy函数的返回类型的设置是为了实现链式访问

模拟实现：

char* my_strcpy(char*dest, const char* src)
{
	char* ret = dest;
	while(*dest++ = *src++)
		;
	return ret;
}

🖌  strcat

函数原型：

char * strcat ( char * destination, const char * source );

函数功能：

将源字符串的副本追加到目标字符串。目标中的终止空字符被源的第一个字符覆盖，并且在目标中由两者串联形成的新字符串的末尾包含一个空字符。

目的地和来源不得重叠。

⭐ 目标空间必须有足够的大，能容纳下源字符串的内容。
⭐ 目标空间必须可修改。

函数使用：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include <assert.h>

int main()
{
	char str[80];
	strcpy(str, "these ");
	strcat(str, "strings ");
	strcat(str, "are ");
	strcat(str, "concatenated.");
	puts(str);
	return 0;
}

目的地和来源不得重叠。所以不可以自己给自己追加喔（strcat（s,s);绝对不可以喔。🙅‍♀️）

模拟实现：

char* my_strcat(char* dest, char* src)
{
	assert(dest && src);
	char* ret = dest;
	//找目标空间中的\0
	while (*dest)
		dest++;
	//拷贝
	while (*dest++ = *src++)
		;
	
	return ret;
}

🖌   strcmp

函数原型：

int strcmp ( const char * str1, const char * str2 );

函数功能：

此函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续以下对，直到字符不同或达到终止空字符。

ps:此函数执行字符的二进制比较。有关考虑特定于区域设置的规则的函数，请参阅 strcoll。

✨ 返回值：
第一个字符串大于第二个字符串，则返回大于 0 的数字
第一个字符串等于第二个字符串，则返回 0
第一个字符串小于第二个字符串，则返回小于 0 的数字

函数使用：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>

int main()
{
    char key[] = "apple";
    char buffer[80];
    do {
        printf("Guess my favorite fruit? ");
        fflush(stdout);//刷新输出缓冲区
        scanf("%79s", buffer);
    } while (strcmp(key, buffer) != 0);
    puts("Correct answer!");
    return 0;
}

  fflush(stdout);作用：刷新输出缓冲区--更多欢迎进入主页查看文件系统与inode编号 有更详细的介绍

模拟实现：

✍ 代码实现：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include <assert.h>


int my_strcmp(const char* s1, const char* s2)
{
	assert(s1 && s2);
	while (*s1 == *s2)
	{
		if (*s1 == '\0')
		{
			return 0;//相等
		}

		s1++;
		s2++;
	}
	//不相等
	return *s1 - *s2;
}
int main()
{
	char * s1 = "abcde";
	char * s2 = "acbde";
	char * s3 = "abcde";
	char * s4 = "abbbbb";
	printf("s1 vs s2 %d\n", my_strcmp(s1, s2));
	printf("s1 vs s3 %d\n", my_strcmp(s1, s3));
	printf("s1 vs s4 %d\n", my_strcmp(s1, s4));
	return 0;
}

📕 运行结果：

⭕ 长度受限制的字符串函数介绍

🖌  strncpy

函数原型：

char * strncpy ( char * destination, const char * source, size_t num );

函数功能：

将源的第一个字符数复制到目标。如果在复制 num 个字符之前找到源 C 字符串的末尾（由 null 字符表示），则目标将填充零，直到总共写入 num 个字符为止。

⭐ 如果源长度超过 num，则不会在目标末尾隐式附加空字符。因此，在这种情况下，不应将目标视为以空结尾的 C 字符串（这样读取它会溢出）。

⭐ 目的地和来源不得重叠 

函数使用：

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

int main ()
{
  char str1[]= "To be or not to be";
  char str2[40];
  char str3[40];

  /* copy to sized buffer (overflow safe): */
  strncpy ( str2, str1, sizeof(str2) );

  /* partial copy (only 5 chars): */
  strncpy ( str3, str2, 5 );
  str3[5] = '\0';   /* null character manually added */

  puts (str1);
  puts (str2);
  puts (str3);

  return 0;
}

运行结果：

模拟实现：

char* my_strncpy(char* destination, const char* source, size_t n)
{
	char* cp = destination;
	int i = 0;
	while (*source && i < n)
	{
		*cp++ = *source++;
		i++;
	}
	for (int j = i; j < n; j++)
	{
		*cp++ = 0;
	}
	return destination;
}

🖌  strncat

函数原型：

char * strncat ( char * destination, const char * source, size_t num );

函数功能：

将源的第一个数字字符追加到目标，外加一个终止空字符。

如果源中 C 字符串的长度小于 num，则仅复制终止空字符之前的内容。

函数使用：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>

int main ()
{
  char str1[20];
  char str2[20];
  strcpy (str1,"To be ");
  strcpy (str2,"or not to be");
  strncat (str1, str2, 6);
  puts (str1);
  return 0;
}

运行结果：

❓  字符串自己给自己追加，如何？
对于strncat函数，它可以在目标字符串中追加源字符串的一部分内容，但不能直接将源字符串追加到自身。

模拟实现：

代码实现：

#include<stdio.h>
#include<assert>
#include<string.h>
 
char* my_strncat(char* dest, const char* src, size_t num) {
	assert(dest && src);
	char* ret = dest;
	/*while (num--) {
		*dest++ = *src++;
	}*/
	while (*dest != '\0') {
		dest++;
	}
	size_t i = 0;
	for (; src != 0 && i < num; i++) {
		dest[i] = src[i];
	}
	return ret;
}
int main() {
	char dest[20] = "hahaha";
	char src[10] = "yyyyyy";
	my_strncat(dest, src, 2);
	printf("%s\n", dest);
	return 0;
}

运行结果：

🖌 strncmp

函数原型：

int strncmp ( const char * str1, const char * str2, size_t num );

函数功能：

比较两个字符串的字符
将 C 字符串 str1 的字符数与 C 字符串 str2 的字符数进行比较。
此函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续使用以下对，直到字符不同，直到达到终止的空字符，或者直到两个字符串中的 num 字符匹配，以先发生者为准。

✨ 返回值：
第一个字符串大于第二个字符串，则返回大于 0 的数字
第一个字符串等于第二个字符串，则返回 0
第一个字符串小于第二个字符串，则返回小于 0 的数字

函数使用：

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

int main ()
{
  char str[][5] = { "R2D2" , "C3PO" , "R2A6" };
  int n;
  puts ("Looking for R2 astromech droids...");
  for (n=0 ; n<3 ; n++)
    if (strncmp (str[n],"R2xx",2) == 0)
    {
      printf ("found %s\n",str[n]);
    }
  return 0;
}

模拟实现：

int my_strncmp(const char *str1, const char *str2, int n)
{
	assert(str1 != NULL&&str2 != NULL);
	while(n--&&*str1 == *str2)
	{
			str1++;
			str2++;
	}
	return *str1 - *str2;
}

⭕ 字符串查找

🖌 strstr

函数原型：

const char * strstr ( const char * str1, const char * str2 );
char * strstr (char * str1, const char * str2 );

函数功能：查找子字符串

返回指向 str1 中第一次出现的 str2 的指针，如果 str2 不是 str1 的一部分，则返回一个空指针。

匹配过程不包括终止空字符，但它到此为止。

函数使用：

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

int main ()
{
//查找出错误的sample并替换为正确的
  char str[] ="This is a simple string";
  char * pch;
  pch = strstr (str,"simple");
  if (pch != NULL)
    strncpy (pch,"sample",6);
  puts (str);
  return 0;
}

运行结果：

模拟实现：

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);

	const char* s1 = str1;
	const char* s2 = str2;

	const char* cur = str1;
	while (*cur)
	{
		s1 = cur;
		s2 = str2;

		while (*s1 && *s2 && (*s1 == *s2))
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
		{
			return (char*)cur;
		}
		cur++;
	}

	return NULL;//找不到
}

🖌   strtok

函数原型：

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

函数功能：

将字符串拆分为以标记分开的字符串。
此函数的一系列调用将 str 拆分为标记，这些标记是由分隔符中的任何字符分隔的连续字符序列。

⭐ 在第一次调用时，该函数需要一个 C 字符串作为 str 的参数，其第一个字符用作扫描令牌的起始位置。在后续调用中，该函数需要一个空指针，并使用最后一个令牌末尾之后的位置作为扫描的新起始位置。

⭐ 为了确定标记的开头和结尾，该函数首先从起始位置扫描分隔符中未包含的第一个字符（该字符将成为标记的开头）。然后从令牌的开头开始扫描分隔符中包含的第一个字符，该字符将成为令牌的末尾。如果找到终止空字符，扫描也会停止。

⭐ 令牌的此结尾将自动替换为空字符，并且令牌的开头由函数返回。

一旦在对 strtok 的调用中找到 str 的终止空字符，则对此函数的所有后续调用（以空指针作为第一个参数）都将返回空指针。

⭐找到最后一个令牌的点由要在下一次调用中使用的函数在内部保留（不需要特定的库实现来避免数据争用）。

函数使用：

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

int main ()
{
  char str[] ="- This, a sample string.";
  char * pch;
  printf ("Splitting string \"%s\" into tokens:\n",str);
  pch = strtok (str," ,.-");
  while (pch != NULL)
  {
    printf ("%s\n",pch);
    pch = strtok (NULL, " ,.-");
  }
  return 0;
}

模拟实现：

char* my_strtok(char* strToken, const char* strDelimit)
{
	char* str1 = strToken;
	char* temp = NULL;
	char* str2 = (char*)strDelimit;
	static char* pos = NULL;
 
	if (str1 != NULL)
	{
		while (*str1)
		{
			str2 = (char*)strDelimit;
			while (*str2 != '\0')
			{
				if ((*str1 == *str2))
				{
					if (*(str1 + 1) == '\0')
						pos = NULL;
					else
						pos = str1;
					*str1 = '\0';
					return strToken;
				}
				str2++;
			}
			str1++;
		}
	}
	else
	{
		if (pos != NULL)
		{
			str1 = pos + 1;
			temp = pos + 1;
			while (*str1)
			{
				str2 = (char*)strDelimit;
				while (*str2 != '\0')
				{
					if ((*str1 == *str2))
					{
						pos = str1;
						*str1 = '\0';
						return temp;
					}
					str2++;
				}
				str1++;
			}
			pos = NULL;
			return temp;
		}	
	}
	return NULL;
}

⭕ 错误信息报告

🖌  strerror

函数原型：

char * strerror ( int errnum );

函数功能：获得一个指向错误信息字符串的字符指针

⭐ 解释 errnum 的值，生成一个字符串，其中包含描述错误条件的消息，就像由库的函数设置为 errno 一样。

⭐ 返回的指针指向静态分配的字符串，程序不应修改该字符串。对此函数的进一步调用可能会覆盖其内容（不需要特定的库实现来避免数据争用）。

⭐ strerror 生成的错误字符串可能特定于每个系统和库实现。

函数使用：

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

int main ()
{
  FILE * pFile;
  pFile = fopen ("unexist.ent","r");
  if (pFile == NULL)
    printf ("Error opening file unexist.ent: %s\n",strerror(errno));
  return 0;
}

 ⭕ 内存操作函数

 🖌 memcpy

函数原型：

void * memcpy ( void * destination, const void * source, size_t num );


函数功能：复制内存块

将字节数的值从源指向的位置直接复制到目标指向的内存块。

⭐ 源指针和目标指针指向的对象的基础类型与此函数无关;结果是数据的二进制副本。

⭐ 该函数不检查源中的任何终止空字符 - 它总是准确地复制字节数。

⭐ 为避免溢出，目标和源参数指向的数组大小应至少为字节数，并且不应重叠（对于重叠的内存块，memmove 是一种更安全的方法）。

函数使用：

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

struct {
  char name[40];
  int age;
} person, person_copy;

int main ()
{
  char myname[] = "Pierre de Fermat";

  /* using memcpy to copy string: */
  memcpy ( person.name, myname, strlen(myname)+1 );
  person.age = 46;

  /* using memcpy to copy structure: */
  memcpy ( &person_copy, &person, sizeof(person) );

  printf ("person_copy: %s, %d \n", person_copy.name, person_copy.age );

  return 0;
}


模拟实现：

void* my_memcpy(void* dest, const void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	while (count--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}

	return ret;
}

 🖌  memmove

函数原型：

void * memmove ( void * destination, const void * source, size_t num );


函数功能：

移动内存块
将字节数的值从源指向的位置复制到目标指向的内存块。复制就像使用了中间缓冲区一样，允许目标和源重叠。

⭐ 源指针和目标指针指向的对象的基础类型与此函数无关;结果是数据的二进制副本。

⭐ 该函数不检查源中的任何终止空字符 - 它总是准确地复制字节数。

⭐ 为避免溢出，目标参数和源参数指向的数组的大小应至少为字节数。

函数使用：

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

int main ()
{
  char str[] = "memmove can be very useful......";
  memmove (str+20,str+15,11);
  puts (str);
  return 0;
}


模拟实现：

void* my_memmove(void* dest, const void*src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	//1
	if (dest < src)
	{
		//前->后
		while (count--)
		{
			*(char*)dest = *(char*)(src);
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		//后->前
		while (count--)
		{
			*((char*)dest+count) = *((char*)src + count);
		}
	}

	return ret;
}

 🖌  memcmp

函数原型：

int memcmp ( const void * ptr1, const void * ptr2, size_t num );


函数功能：比较两个内存块

将 ptr1 指向的内存块的前 num 字节数与 ptr2 指向的第一个字节数进行比较，如果它们都匹配，则返回零，如果不匹配，则返回一个不同于零的值，表示哪个更大。

✴ 请注意，与 strcmp 不同，该函数在找到空字符后不会停止比较。

函数使用：

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

int main ()
{
  char buffer1[] = "DWgaOtP12df0";
  char buffer2[] = "DWGAOTP12DF0";

  int n;

  n=memcmp ( buffer1, buffer2, sizeof(buffer1) );

  if (n>0) printf ("'%s' is greater than '%s'.\n",buffer1,buffer2);
  else if (n<0) printf ("'%s' is less than '%s'.\n",buffer1,buffer2);
  else printf ("'%s' is the same as '%s'.\n",buffer1,buffer2);

  return 0;
}


模拟实现：

🔪 方式一：

int my_memcmp1(const void* p1, const void* p2, size_t count)//方法1
{
    assert(p1);
    assert(p2);
    char* dest = (char*)p1;
    char* src = (char*)p2;
    while (count && (*dest == *src))
    {
        count--;
        dest++;
        src++;
    }
    if (count == 0)
        return 0;
    return *dest - *src;
}

🔪 方式二：

int my_memcmp2(const void* p1, const void* p2, size_t count)//方法2
{
    assert(p1);
    assert(p2);
    int ret = 0;
    char* dest = (char*)p1;
    char* src = (char*)p2;
    while (count && (!(ret = (*dest - *src))))
    {
        dest++;
        src++;
        count--;
    }
    if (ret > 0)
    {
        return 1;
    }
    else if (ret < 0)
    {
        return -1;
    }
    return 0;

}

 🖌   memset

函数原型：

void * memset ( void * ptr, int value, size_t num );


函数功能：填充内存块

将 ptr 指向的内存块的第一个字节数设置为指定值（解释为无符号字符）。

函数使用：

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

int main ()
{
  char str[] = "almost every programmer should know memset!";
  memset (str,'-',6);
  puts (str);
  return 0;
}

 

秋秋爱代码
关注
  • 5
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值