内存函数详解,包含部分字符串函数

目录

一,memcpy内存函数的介绍

二memmove函数的介绍

三,memset的函数使用

四,memcmp的介绍

五,内存函数的模拟实现,以及一个字符串函数strstr的模拟实现

5.1memcpy函数的实现

5.2memmove的模拟实现

5.3memcmp的模拟实现

[5.4 strstrg函数的模拟实现(暴力实现以及KMP算法实现)](#5.4 strstrg函数的模拟实现(暴力实现以及KMP算法实现))


内存操作函数

memcpy的使用以及模拟实现

memmove的使用以及模拟实现

memcmp的使用以及模拟实现

memset的使用

strstr的模拟实现

一,memcpy内存函数的介绍

void* memcpy(void* destination, const void* source, size_t num);
这里我们可以看到,他是有三个参数的,其中有俩个无符号指针,还有一个是无符号的num
这俩个指针,一个指向目标要改变的数据的地址,另一个是源地址,要拷贝到我们目标中
当然这里使用无符号类型的指针,是为了我们能拷贝任何类型的数据,就不仅限于拷贝字符

解释如下
函数 memcpy 从 source 的位置开始向后复制 num 个字节的数据到 destination 的内存位置。
这个函数在遇到 '\0' 的时候并不会停下来,因为我们给了需要拷贝的字节大小,所以拷贝停止是由我们自己来控制的
如果 source 和 destination 有任何的重叠,复制的结果都是未定义的。
这个意思是所不能在自己的后面拷贝自己,因为可能会导致越界的风险,当然在VS下是可以自己拷贝自己的内容的,但是在不同的编译器中,可能效果不同,有些编译器是不允许这样使用的

这便是在自己后面进行拷贝,然后出现越界的情况,例如在字符串中,他在拷贝的过程中,可以会将'\0'修改,导致字符串没有结尾标志。

可以看到,我们将arr2中的数据拷贝到了arr1中去,而arr1和arr2中存放的都是int类型的变量,这就是和字符串拷贝的区别,当然我们也可以拷贝其他类型的变量,例如结构体

二memmove函数的介绍

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

这里我们可以看到,他是有三个参数的,其中有俩个无符号指针,还有一个是无符号的num
这俩个指针,一个指向目标要改变的数据的地址,另一个是源地址,要拷贝到我们目标中
当然这里使用无符号类型的指针,是为了我们能拷贝任何类型的数据,就不仅限于拷贝字符

和 memcpy 的差别就是 memmove 函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠,就得使用 memmove 函数处理。

当然他也能在字符串后面去追加自己的部分

我们可以看到,他是能在他自己的后面追加内容的。

三,memset的函数使用

void *memset( void * dest , int c , size_t count );

memset函数,有三个参数,一个是无符号的指针,一个是你要设置的符号是什么,最后一个参数是无符号的整形,返回类型是无符号的指针类型,指向的是 *dest的首元素地址

memset函数的功能是,在dest里面设置count字节的符号C,并返回dest的地址

我们使用memset就能使我们想要的字节个数的内容变成我们需要的值。

四,memcmp的介绍

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

我们可以看到,他有三个参数,前俩个是我们要比较内容的地址,最后一个是我们要比较的个数,返回类型是int类型,如果ptr1 > ptr2 则返回 > 0 的数,如果ptr1 < ptr2 则返回 0 < 的数,如果 ptr1 == ptr2 则返回 0

五,内存函数的模拟实现,以及一个字符串函数strstr的模拟实现

5.1memcpy函数的实现

cpp 复制代码
void* my_memcpy(void* dest, const void* cur, size_t num)
{
	//保留dest的地址
	void* ret = dest;
	while (num)
	{
		*(char*)dest = *(char*)cur;
		dest = (char*)dest + 1;
		cur = (char*)cur + 1;
		num--;
	}
	//返回dest的地址
	return ret;
}
int main()
{

	char str1[] = "hello world .............";
	char str2[] = ".............";
    //将str2的前5个字节的内容拷贝到str1中
	my_memcpy(str1,str2,5sizeof(str2[0]));
	
	printf(str1);

	return 0;
}

5.2memmove的模拟实现

图,一

图,二

当然在拷贝自己时会出现上述俩种情况,如果我们一直只选一直拷贝方式,例如,从前向后拷贝因为cur和dest都是来自同一部分,那么会出现什么情况呢,我们在dest > cur时,在拷贝的时候就已经将存储在a ,b ,c 之后的数据d,e,f修改为 a,b,c 因为dest和cur指向的是同一块内容,那么cur里面的数据 d,e,f也被修改了,那么就达不到我们需要的拷贝效果。这时我们就要进行一定的判断,当dest > cur时,我们从后向前拷贝,当 cur > dest时我们从前向后拷贝。当然,如果不是相同地址块的内容,如何拷贝不会影响他们的结果,这个判断只对拷贝同一块地址内容进行区分。

代码如下

cpp 复制代码
void* my_memmove(void* dest, const void* cur, size_t num)
{
	void* ret = dest;
	//为了防止自己拷贝自己导致的内容覆盖
    //如果dest < cur
	if (dest < cur)
	{
		while (num)
		{
			*(char*)dest = *(char*)cur;
			dest = (char*)dest + 1;
			cur = (char*)cur + 1;
			num--;
		}
	}
	else
	{
		dest = (char*)dest + num;
		cur = (char*)cur + num;
		while (num)
		{
			*(char*)dest = *(char*)cur;
			dest = (char*)dest - 1;
			cur = (char*)cur - 1;
			num--;
		}
	}
}
int main()
{

	char str1[] = "hello world .............";
	char str2[] = ".............";
	my_memmove(str1,str1+5,6);
	
	printf(str1);

	return 0;
}


5.3memcmp的模拟实现

cpp 复制代码
int my_memcmp(void* pstr1, char* pstr2, size_t num)
{

	while (num)
	{
		//如果某个字节的值不相等,则中断循环
		if (*(char*)pstr1 != *(char*)pstr2)
		{
			break;
		}
		//相等这继续向下走
		pstr1 = (char*)pstr1 + 1;
		pstr2 = (char*)pstr2 + 1;
		num--;
	}
	//直接返回pstr1 和 pstr2对应的差值即可
	return (*(char*)pstr1 - *(char*)pstr2);
}

int main()
{

	char str1[] = "hello world .............";
	char str2[] = "hello word";
	int ret = my_memcmp(str1,str2,5);
	
	printf("ret = %d",ret);

	return 0;
}

可以看到,直接返回了不相等部分的差值,大于0 说明前num个字节 str1大于str2

可以看到,直接返回了相等部分的差值,等于0 说明前num个字节 str1等于str2

5.4 strstrg函数的模拟实现(暴力实现以及KMP算法实现)

暴力实现:

cpp 复制代码
char* my_strstr(const char* ps1, const char* ps2)
{
	char* p1 = ps1;
	char* p2 = ps2;
	char* p3 = ps1;

	while (*p3 != '\0')
	{
		//每次循环一次,将p3指向的下一个内容给p1,p2回到子集的起点
		p1 = p3;
		p2 = ps2;
		while (*p2 != '\0')
		{
			if (*p2 == *p1)
			{
				//相等就p1和p2向后走,一直比较到 p2指向'\0'为止
				p2++;
				p1++;
			}
			else
			{
				//如果在p2到'\0'之前不相等,这直接跳出循环
				break;
			}
		}
		//如果*p2 == '\0' 那么说明以及在ps1中的子集里找到了与ps2相等的部分,那么就可以返回p3所指向的内容,
		if (*p2 == '\0')
		{
			return p3;
		}
		//如果不相等,p3向后走一位
		p3++;
	}
	//如果一直到最后都没有找到那么将返回空
	return NULL;
}

int main()
{

	char str1[] = "abcdeffghjkln";
	char str2[] = "ffg";

	char* ret = my_strstr(str1,str2);

	printf(ret);

	return 0;
}


KMP算法:
next数组:

由上图next数组我们可以知道

如果我们只知道i之前的next数组下标,那么他之后的应该按照 next[i+1] = k+1,去计算
而图中我们要求的是 i 位置的next数据,那么如果字符串第 i - 1 位置的字符与 k 位置的字符相等,那么next[i] 位置的值就等于 next [i] = next[i-1] + 1,当然,如果 i 的前一个位置的字符串不等于 k 位置的字符串,那么next数组回退到 k 指向的位置,如果一直不相等,直到 k 会退到 -1位置处,在出现进行比较

cpp 复制代码
void GetNext(char* ps2,int* next,int len2)
{
	next[0] = -1;
	next[1] = 0;
	
	int i = 2;
	int k = 0;
    //一直插入数据到next的最后一个位置
	while(i < len2)
	{
        // 如果 k 等于 -1 那么说明已经回退到原点,或者 第 i 的前一项与k位置的字符相等 
		if (k == -1 ||ps2[i - 1] == ps2[k])
		{
			next[i] = k + 1;
			i++;
			k++;
		}
        //不相等这 k 回退到next[k]对应的值
		else
		{
			k = next[k];
		}
	}
}
cpp 复制代码
char* KMP( char* ps1,  char* ps2,int pos)
{
	int len1 = strlen(ps1);
	int len2 = strlen(ps2);
    //我们要找的子串,和需要的主串不能为空
	if (len1 == 0 || len2 == 0)
	{
		return NULL;
	}
    //我们希望开始比较的位置不能大于主串的长度,也不能小于零
	if (pos<0 || pos > len1)
	{
		return NULL;
	}
    //数组这里我们选择动态开辟在堆上建next数组
	int* next = (int*)malloc(sizeof(int) * len2);
    //如果malloc失败这直接返回
	if (next == NULL)
	{
		return;
	}
    //函数得到我们的next数组
	GetNext(ps2, next,len2);
	int i = pos;//遍历主串
	int j = 0;//遍历子串
    //在主串中寻找子串
	while (i < len1 && j < len2)
	{
        //如果 j = -1;这说明需要比较下一个,相等这比较下一个
		if (j == -1||ps1[i] == ps2[j])
		{
			i++;
			j++;
		}
        //不相等将 j 更新为next[k] 对应的值在重新去比较
		else
		{
			j = next[j];
		}
	}
    //释放我们在堆上申请的空间
    free(next);
    // 如果j >= len2的长度则说明已经找到主串中的子串,返回对应位置的地址
	if (j >= len2)
	{
		
		return &ps1[i - j];
	}
	//没有找到返回空
	return NULL;
}

KMP整体代码如下

cpp 复制代码
#include<stdio.h>
#include<stdlib.h>
void GetNext(char* ps2,int* next,int len2)
{
	next[0] = -1;
	next[1] = 0;
	
	int i = 2;
	int k = 0;
	while(i < len2)
	{
		if (k == -1 ||ps2[i - 1] == ps2[k])
		{
			next[i] = k + 1;
			i++;
			k++;
		}
		else
		{
			k = next[k];
		}
	}
}
char* KMP( char* ps1,  char* ps2,int pos)
{
	int len1 = strlen(ps1);
	int len2 = strlen(ps2);
	if (len1 == 0 || len2 == 0)
	{
		return NULL;
	}
	if (pos<0 || pos > len1)
	{
		return NULL;
	}
	int* next = (int*)malloc(sizeof(int) * len2);
	if (next == NULL)
	{
		return;
	}
	GetNext(ps2, next,len2);
	int i = pos;//遍历主串
	int j = 0;//遍历子串
	while (i < len1 && j < len2)
	{
		if (j == -1||ps1[i] == ps2[j])
		{
			i++;
			j++;
		}
		else
		{
			j = next[j];
		}
	}
	if (j >= len2)
	{
		free(next);
		return &ps1[i - j];
	}
	free(next);
	return NULL;
}

int main()
{

	char str1[] = "abcdeffghjkln";
	char str2[] = "ffghjk";

	char* ret = KMP(str1,str2,0);

	printf(ret);

	return 0;
}
相关推荐
qystca34 分钟前
洛谷 B3637 最长上升子序列 C语言 记忆化搜索->‘正序‘dp
c语言·开发语言·算法
网易独家音乐人Mike Zhou6 小时前
【卡尔曼滤波】数据预测Prediction观测器的理论推导及应用 C语言、Python实现(Kalman Filter)
c语言·python·单片机·物联网·算法·嵌入式·iot
搬砖的小码农_Sky9 小时前
C语言:数组
c语言·数据结构
ahadee13 小时前
蓝桥杯每日真题 - 第19天
c语言·vscode·算法·蓝桥杯
Theliars13 小时前
C语言之字符串
c语言·开发语言
Reese_Cool13 小时前
【数据结构与算法】排序
java·c语言·开发语言·数据结构·c++·算法·排序算法
搬砖的小码农_Sky14 小时前
C语言:结构体
c语言·数据结构
平头哥在等你16 小时前
求一个3*3矩阵对角线元素之和
c语言·算法·矩阵
尹蓝锐16 小时前
C语言-11-18笔记
c语言
ahadee16 小时前
蓝桥杯每日真题 - 第18天
c语言·vscode·算法·蓝桥杯