常用的字符函数及其字符串函数

奥斯卡小金豆

已于 2022-11-03 12:11:51 修改

阅读量221

点赞数

文章标签： c++ 算法后端

于 2022-10-28 14:30:48 首次发布

本文链接：https://blog.csdn.net/weixin_48440155/article/details/127570584

版权

常用的字符函数和字符串函数

strlen----------求字符串长度
strcpy-----------复制字符串
strcat-----------追加字符串
strcmp-----------比较字符串大小
长度受限制的字符串函数介绍
strncpy---------自定义需要拷贝多少个字符
strncat---------自定义需要插入多少个字符
strncmp---------自定义需要比较的字符串长度
字符串查找
strstr----------查找一个字符串在另一个字符串中是否存在
strtok---------分割字符串
错误信息报告
strerror
字符操作
内存操作函数
memcpy------复制源头空间的数据到目的地空间（当空间出现重叠，复制的结果不确定）
memmove-----复制源头空间的数据到目的地空间（当空间出现重叠，依然可以使用）
memset------对一段内存空间进行自定义的初始化
memcmp------比较两个字符串从第一个元素开始后到第n个字符串的大小

strlen

size_t strlen ( const char * str );

strlen是用来求字符串str长度的函数，单位字节。从字符首位置开始遍历字符串，当遇到’\0’便停止。
然后将字符串的长度返回。
size_t类型表示返回的是一个unsigned int，是一个无符号数，因为长度没有负数。
const用来定义常量，当一个变量被const修饰，那么将不能被更改。
而strlen只用计算字符串的长度，防止改变str,所以用const修饰。

strlen的模拟实现

`int my_strlen(const char * str)
{
 int count = 0;
 while(*str)
 {
 count++;
 str++;
 }
 return count;
}`

strcpy

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

将源空间字符串source拷贝到目标空间destination

返回值char*：返回destination首地址

要求

1.源空间字符串以\0"结束

2.目标空间足够存储拷贝的字符串加原来的字符串

3.目标空间可改变

模拟实现

char *my_strcpy(char *dest, const char*src)
{ 
 char *ret = dest;
 assert(dest != NULL); 
 assert(src != NULL);

 while((*dest++ = *src++))
 {
 ;
 }
 return ret;
}

char* ret 记录dest首地址返回使用
assert 断言源空间和目标空间不为0；
`*dest++=*src++`将源空间的字符*后赋给目标空间，后++，当src把'\0'赋给dest后，整个表达式为0，结束循环。

strcat

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

将源空间的字符串追加到目标空间字符串之后（源字符串第一个字符放到目标目标空间字符串’\0’处）

返回值char*:返回destination首地址

要求

1.目标空间足够大且以’\0’结束

2.源空间字符串以’\0’结束

模拟实现


```c
 char *my_strcat(char *dest, const char*src) 
 {
char *ret = dest; 
assert(dest != NULL); 
assert(src != NULL); 
while(*dest) 
{ dest++;
} 
while((*dest++ = *src++))
{ 
; 
}
 return ret;`
`}

模拟思想：先找到目标空间的’\0’,从’\0’开始追加字符串

strlcmp

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

将 C 字符串 str1 与 C 字符串 str2 进行比较。此函数开始比较每个字符串的第一个字符。如果它们彼此相等，则继续执行以下对操作，直到字符不同或达到终止空字符。

返回值int：当str1大于str2返回大于0的数；当str1小于str2返回小于0的数；当str1等于str2返回0；

模拟实现

  int* my_strcmp(const char* dest, const char* src)
 {
    assert(dest && src);
	int a = 0;
	int b = 0;

	while (*dest++)
	{
		a++;
	}
	while (*src++)
	{
		b++;
	}
	return a - b;
}

模拟思想：定义两个变量计数，遍历两个字符串，返回差值

strcpy

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

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

如果源大于 num，则不会在目标末尾隐式追加空字符。因此，在这种情况下，不应将目标视为空终止的 C 字符串（这样读取它会使溢出）。

目标和源不得重叠（有关重叠时更安全的替代方案，请参见 memmove）。

返回值char*：返回目标空间首地址

要求

1.目标空间足够大且以’\0’结束

2.源空间字符串以’\0’结束

模拟实现

char* my_strncpy(char* dest, const char* src, int num)
{
      assert(dest&&src);
      char* ret = dest;
      int i = 0;

    for (i = 0; i < num; i++)
    {
	     dest[i] = src[i];
    }
     return ret;
}

模拟思想：以num作为循环的停止条件，循环停止，说明num个字符已经拷贝完

strncat

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

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

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

返回值char*：返回destination首地址

要求

1.目标空间足够大且以’\0’结束

2.源空间字符串以’\0’结束

模拟实现

char* my_strncat(char* str, const char* str1, char num)
{
	assert(str&&str1);
	
	while (*str)
	{
		str++;
	}

	for (int i = 1; i <= num; i++)
	{
			*str++=*str1++;
	}
	
}

模拟思想：先找到目标空间的’\0’,再循环num次将源空间的字符赋进目标空间

strncmp

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

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

返回值int：当str1大于str2返回大于0的数；当str1小于str2返回小于0的数；当str1等于str2返回0；

要求

1.只比较大小，不改变字符串的内容

2.两个字符串不为NULL

模拟实现

int my_strncmp(const* str1, const* str2, size_t num)
{
   char i = 0;

     char* ptr1 = str1;
     char* ptr2 = str2;
for (i = 1; i <= num; i++)
{

     if (*ptr1!=*ptr2)
{
    return (*ptr1 - *ptr2);
}
      ptr1 = ptr1 + 1;
      ptr2 = ptr2 + 1;
}
    return 0;
}

strstr

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

在一个字符串中查找另一个字符串是否存在

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

要求

1.只比较大小，不改变字符串的内容

2.两个字符串不为NULL

char* my_strstr(const char* str1, const char* str2)
{
	const char* s1 = str1;
	const char* s2 = str2;
	const char* p = str1;
	if (*str1 == '\0')
	{
		return NULL;
	}
	while (*p)
	{
		s1 = p;
		s2 = str2;
		while (*s1!='\0' && *s2 != '\0' && *s1 == *s2)
		{
			s1++;
			s2++;
			if ('\0' == *s2)
			{
				return str1;
			}
		}
		p++;
	}

		return NULL;

}

strtok

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

sep参数是个字符串，定义了用作分隔符的字符集合
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标
记。

strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：
strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容
并且可修改。）

strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串
中的位置。

strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标
记。

如果字符串中不存在更多的标记，则返回 NULL 指针。

#include <stdio.h>
#include <string.h>
int main()
{
   char *p = "zhangsan@baidu.tech";
 const char* sep = ".@";
 char arr[30];
 char *str = NULL;
 strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容
 for(str=strtok(arr, sep); str != NULL; str=strtok(NULL, sep))
 {
 printf("%s\n", str);
 }
}

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));
    //errno: Last error number
  return 0;
}

memcpy

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

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

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

该函数不检查源代码中的任何终止空字符 - 它始终精确复制数字字节。

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

模拟实现

void* my_memcpy(void* dest, const void* src, size_t num)
{
	assert(src);
	void* ret = dest;
	while (num--)
	{
		*((char*)dest)++ = *((char*)src)++;

	}
	return ret;
}

smemmove

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

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

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

该函数不检查源代码中的任何终止空字符 - 它始终精确复制数字字节。

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

void* my_move(void* dest, const void* src, size_t num)
{
	assert(src);
	void* ret = dest;
	if (dest < src)
	{
		while (num--)
		{
			//*((char*)dest)++ = *((char*)src)++;
			//某些编译器跑不了
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	return ret;
}

memset

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

填充内存块
自定义初始化
将 ptr 所指向的内存块的前 num（自定义）个字节设置为指定的值（解释为无符号字符）。

示例

int main() 
{
	 int arr[10];
	 int i = 0;
	memset(arr, 0, sizeof(int) * 10);
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

memcmp

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

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

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

   size_t num 比较的单位是字节

返回值int：当ptr1大于ptr2返回大于0的数；当ptr1小于ptr2返回小于0的数；当ptr1等于ptr2返回0；

示例

int main()
{
	int arr[] = { 1,2,3,4,5 };
	int arr1[] = { 1,2,2 };
	int ret = memcmp(arr, arr1, sizeof(int)*2);
	printf("%d",ret);
	return 0;
}

模拟实现

int my_memcmp(const void* ptr1, const void* ptr2, size_t num)
{
	char i = 0;
	
	char* str1 = (char*)ptr1;
	char* str2 = (char*)ptr2;
	for (i = 1; i <= num; i++)
	{
		
		if (*(char*)str1 != *(char*)str2)
		{
			return (*(char*)str1 - *(char*)str2);
		}
		 str1 = (char*)str1 + 1;
		 str2 = (char*)str2 + 1;
	}
	return 0;
}

int main()
{
	char arr1[] = "abca";
	char arr2[] = "accd";
	int ret = my_memcmp(arr1, arr2, sizeof(char) * 2);
	printf("%d",ret);

	return 0;
}

奥斯卡小金豆

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
常用的字符函数及其字符串函数

对常用的字符函数字符串函数的解析及部分函数的模拟实现包含（strlen strcat strcpy strcmp strstr strtok strncat strncpy strncmp memcmp memcpy memmove memset）
复制链接

扫一扫