字符函数和内存函数代码实现

---

前言

了解C语言内置库函数的实现有助于我们更好的使用库函数，并提高编程能力。

---

写在前面

assert

为增强代码的健壮性，需要对不需要修改的参数添加const加粗样式修饰
为防止某些时候参数不能为0（比如指针），防止出现错误时不方便查找，可使用断言assert()
我们来了解一下它的使用


使用例子：

#include

void test(int* p)
{
     
	assert(p);//加上断言，如果p为空（0）程序中断，发生报错
}

int main()
{
     
	test(NULL);//传入空值
	return 0;
}

一、求字符串长度

strlen

目的：

• 计算字符串的长度，不算’\0’

要求：

• 字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )。
• 参数指向的字符串必须要以 ‘\0’ 结束。
• 注意函数的返回值为size_t，是无符号的（ 易错 ）

首先官网查一下函数原型

返回值和参数

有三种实现方法：

1. 常规计数

//模拟实现strlen
int my_strlen(const char* str)
{
     
	assert(str);//断言
	int count = 0;
	while (*str++!='\0')//后置加加，判断是否读取到'\0'
	{
     		
		count++;
	}
	return count;
}

2. 不创建临时变量——递归计算

int my_strlen(const char* str)
{
     
	assert(str);//断言
	if (*str == '\0')//递归到'\0'停止，或者是空字符串
		return 0;
	else//指针向后移一个字节
		return 1 + my_strlen(str + 1);
} 

3. 使用指针-运算

int my_strlen(const char* str)
{
     
	assert(str);//断言
	char* tail = str;//定义一个临时变量，用于指向字符串的末尾
	//遍历字符串
	while (*tail++ != '\0')
	{
     
		;
	}
	//指针加减的到的是之间相差的该类型大小的个数
	//tail最后加1，需要减去
	return tail - str - 1;
}

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

strcpy

目的：

• 源字符串拷贝到目标字符串

要求：

• 源字符串必须以 ‘\0’ 结束。
• 会将源字符串中的 ‘\0’ 拷贝到目标空间。
• 目标空间必须足够大，以确保能存放源字符串。
• 目标空间必须可变。

实现：

char* my_strcpy(char* dest, const char* src)
{
     
	assert(dest && src);//两个字符串的指针都不能为空

	char* temp = dest;
	//src完全覆盖dest，两个指针分别向后移动，并完成赋值，当src指向'\0'时停止
	//前提是目的字符串有住够的空间
	while (*temp++ = *src++)
	{
     
		;
	}
	return dest;
}

strcat

目的：

• 向目的字符串追加字符串

要求：

• 源字符串必须以 ‘\0’ 结束。
• 目标空间必须有足够的大，能容纳下源字符串的内容。
• 目标空间必须可修改。

实现：

char* my_strcat(char* dest, const char* src)
{
     
	assert(dest && src);

	char* temp = dest;
	//查找到dest的末尾
	while (*temp != '\0')
	{
     
		temp++;
	}
	//从末尾开始追加字符串
	while (*temp++ = *src++)
	{
     
		;
	}
	return dest;
}

strcmp

目的：

• 比较两个字符串的大小，比较的是内容，不是长度

返回值：

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

int my_strcmp(const char* str1, const char* str2)
{
     
	assert(str1 && str2);
	while (*str1 == *str2)
	{
     
		//如果两个指针指向的内容直到遇到'\0'一直相等，那么两个字符串相等
		if (*str1 == '\0')
			return 0;
		//向后移动
		str1++;
		str2++;
	}
	//如果遇到不相等的字符，互相比较即可得出结果
	return *str1 - *str2;
}

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

前面三个字符函数没有长度限制，容易溢出或越界访问，C语言提供了对应指定长度得函数。

strncpy

int main()
 {
     
	char arr1[20] = "abcdefghi";
	char arr2[] = "xxx";//长度为3
	strncpy(arr1, arr2, 6);//若复制的字符个数超出它本身个数，目的字符串后面补'\0'

 	printf("%s\n", arr1);
	return 0;
}

strncat

函数参数与strncpy相同
注意点：

• 追加后默认补’\0’

strncmp

多一个比较的字符个数

四、字符串查找

strstr

目的：

• 在一个字符串里面查找一个字符串

返回值：

• 若找到返回第一个出现要查找的字符地址
• 没找到返回NULL
  
  实现：

char* my_strstr(const char* str1, const char* str2)
{
     
	assert(str1 && str2);
	//如果要查找的字符为空，直接返回str1
	if (str2 == '\0')
		return str1;

	char* s1;//用于指向str1
	char* s2;//用于指向str2
	char* s3 = (char*)str1;//用于记录查找到的首字符地址

	while (*s3)
	{
     
		s1 = s3;
		s2 = (char*)str2;

		//两个字符串是否到末尾，判断是否相等
		while (*s1 != '\0' && *s2 != '\0' && *s1 == *s2)
		{
     
			//向后继续比较
			s1++;
			s2++;
		}

		//如果直到str2的末尾仍然相等，那么找到字符串，返回标记的地址
		if (*s2 == '\0')
			return s3;

		//若找不到，标记点向后移位
		s3++;
	}
	return NULL;
}

strtok

目的：

• 一个以传入分隔符为断点，将字符串分隔开

要求：

• 原字符串在函数内被修改，需要传入临时数组

用法：

可以看出，使用一次只能分隔出一段，要把整个字符串分隔开，需要多次使用。
strtok函数第一次使用时，它会记录下分隔符处的地址（类似静态变量）供下次使用，如果第一个参数传入NULL，它就会自动使用那个地址作为初始地址，这样就可以实现多次分隔。

这样就可以利用for循环实现对任意一个字符串分隔

int main()
{
     
	char arr[] = "www.sss.com";
	char arr1[100] = {
      0 };//用做临时存放，不修改原字符串
	strcpy(arr1, arr);
	char arr2[] = ".";
	char* ret = NULL;
	for (ret = strtok(arr1, arr2); ret != NULL ; ret = strtok(NULL, arr2))
	{
     
		printf("%s\n", ret);
	}

	//printf("%s\n", strtok(arr1, arr2));
	//printf("%s\n", strtok(NULL, arr2));
	//printf("%s\n", strtok(NULL, arr2));
	return 0;
}

五、错误信息报告

strerror

**错误码：**写代码可能会发生的错误有很多，每个错误都有对应的数值码，就称为错误码，对应的错误码有对应的错误信息（字符串）

strerror
目的：

• 返回传入错误码对应的错误信息的地址
  
  errno是此时程序发生错误产生的错误码
  需要头文件

#include
#include
#include
int main()
{
     
	//printf("%s\n", strerror());
	FILE* fp = fopen("sss.txt", "r");//以读的形式打开不存在的文件，必然失败
	if (fp == NULL)
	{
     
		printf("%d\n", errno);
		printf("%s\n", strerror(errno));
	}
	return 0;
}

六、内存操作函数

直接作用于内存，按字节进行操作，任意类型都可使用。

memcpy

注意事项：

• 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
• 这个函数在遇到 ‘\0’ 的时候并不会停下来。
• 如果source和destination有任何的重叠，复制的结果都是未定义的。（即如果是在同一个数组上操作，复制的字节出现重叠，不可使用）
  
  

模拟实现：

#include
#include
void* my_memcpy(void* dest, const void* src, size_t count)
{
     
	assert(dest && src);
	//count是无符号整型的别名
	//因为不知道操作的具体是什么类型，所以采用无类型（全能）指针void*接收
	void* ret = dest;
	while (count--)
	{
     
		//将指针全部强转为字符指针，使得指针只能操作一个字节
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;//指针向后移一个字节
		src = (char*)src + 1;
	}
	return ret;
}

memmove

目的：

• 解决memcpy的缺陷，可以完成memcpy的所有功能，并且可以在同一个数组，复制的字节出现重叠时可使用。

如果源空间和目标空间出现重叠，就得使用memmove函数处理。

实现：

#include
#include

void* my_memmove(void* dest, const void* src, size_t count)
{
     
	assert(dest && src);
	void* ret = dest;
	if (dest > src)
	{
     
		//源字符串右向左复制
		while (count--)
		{
     
			*((char*)dest + count) = *((char*)src + count);
		}

	}
	else
	{
     
		//源字符串左向右复制
		//与memcpy类似
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;//指针向后移一个字节
		src = (char*)src + 1;
	}
	return ret;
}
int main()
{
     
	int arr1[] = {
      1,2,3,4 };
	my_memmove(arr1 + 1, arr1, 12);//dest>src - 1,1,2,3

	for (int i = 0; i < 4; i++)
	{
     
		printf("%d ", arr1[i]);
	}
	printf("\n");
	int arr2[] = {
      1,2,3,4 };
	my_memmove(arr2, arr2 + 1, 12);//dest
	for (int i = 0; i < 4; i++)
	{
     
		printf("%d ", arr2[i]);
	}
	printf("\n");

	return 0;
}

memset

目的：

• 将指针往后的指定字节大小，替换为某个值。

int main()
{
     
	int arr[] = {
      1,2,3,4,5,6 };
	memset(arr, 1, 24);

	return 0;
}

memcmp

目的：

• 比较两个指针指向空间的值大小（按字节比较），返回值与strcmp相同。
  

---

总结

不得不说这些函数全部实现一遍对代码能力有很强的提升。