内存函数实例示例 C语言

在我们学习C语言的过程中，内存函数是必不可少的一部分，本篇文章为大家介绍一些内存函数的原理实现：1.strlen，2.strcpy，3.strcmp，4.strcat，5.strstr，6.memcpy，7.memmove；

1.strlen是返回C字符串的长度的函数：

 C字符串的长度由终止的null字符决定：AC字符串，只要是字符串开头和终止的null之间的字符数（不包括终止的null字符串本身）。

代码示例：

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

//模拟实现strlen

int my_strlen(const char*p) {//指针
	int temp = 0;
	while (*p != '\0') {
		temp += 1;
		p++;
	}
	return temp;
}

int my_strlen1(const char* p) {//递归
	if (*p != '\0') {
		return 1 + my_strlen(++p);
	}
	else
		return 0;
}

int main() {
	char arr[] = "abcdefg";
	int ret = my_strlen(arr);//调用方法一
	int ret1=my_strlen1(arr);//调用方法二
	printf("%d\n", ret);
	printf("%d", ret1);
	return 0;
}

运行结果：

2.strcpy是复制字符串的函数

将源指向的C字符串复制到目标指向的数组中，包括终止的null字符（并在该点停止）。

为了避免溢出，目标指向的数组的大小应足够长，以包含与源相同的C字符串（包括终止的null字符），并且在内存中不应与源重叠。

 代码示例：

//模拟实现strcpy
#include<stdio.h>
#include<string.h>
#include<assert.h>

char* my_strcpy( char*p1,const char*p2) {
	char* temp = p1;
	assert(p1 != NULL);
	assert(p2 != NULL);
	while (*p2 != '\0') {
		*p1 = *p2;
		p1++;
		p2++;
	}
	*p1 = *p2;
	p1 = temp;
	return p1;
}

int main() {
	char arr1[20] = "abcdefg";
	char arr2[] = "XXXXXX";
	my_strcpy(arr1,arr2);
	printf("%s\n", arr1);
	return 0;
}

运行结果：

3. strcmp是比较两个字符串的函数

 

将C字符串str1与C字符串str2进行比较。

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

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

代码示例：

//模拟实现strcmp
> 1
= 0
< -1
#include<stdio.h>
#include<string.h>
#include<assert.h>

int my_strcmp(const char*p1,const char*p2) {
	assert(p1 && p2);
	while (*p1 != '\0' && *p2 != '\0') {
		if (*p1 - *p2 == 0) {
			p1++;
			p2++;
		}
		else if (*p1 - *p2 > 0)
			return 1;
		else if (*p1 - *p2 < 0)
			return -1;
	}
	if (*p1 == '\0' && *p2 != '\0')
		return -1;
	if (*p1 != '\0' && *p2 == '\0')
		return 1;
	return 0;
}

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

	while (*str1 == *str2)
	{
		if (*str1 == '\0')
			return 0;

		str1++;
		str2++;
	}

	return (*str1 - *str2);
}

int main() {
	char arr1[] = "abcdef";
	char arr2[] = "abcdefgh";
	int ret = my_strcmp(arr1,arr2);
	switch (ret)
	{
	    case 0:
		    printf("等于");
			break;
		case 1:
			printf("大于");
			break;
		case -1:
			printf("小于");
			break;
		default:
			break;
	}
	return 0;
}

运行结果：

 4.strcat是连接字符串的函数

 

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

目的地和来源地不得重叠。

代码示例：

//模拟实现strcat
#include<stdio.h>
#include<string.h>
#include<assert.h>

char* my_strcat(char*p1,const char*p2) {
 assert(p1 && p2);
	char* temp = p1;
	while (*p1 != '\0')
		p1++;
	/*while (*p1++ = *p2++) {
		;
	}*/
	while (*p2 != '\0') {
		*p1 = *p2;
		p1++;
		p2++;
	}
	return temp;
}

int main() {
	char arr1[20] = "abcdef";
	char arr2[] = "ghlmno";
	my_strcat(arr1, arr2);
	printf("%s", arr1);
	return 0;
}

运行结果：

 5.strstr是定位子字符串的函数

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

匹配过程不包括终止的null字符，但仅限于此。

代码示例：

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

char* my_strstr(const char*p1,const char*p2) {
	assert(p1 && p2);
	char* temp = p1;
	char* move1 = p1;
	char* move2 = p2;
	while (*move2 != '\0') {
		if (*move1 == *move2) {
			move1++;
			move2++;
		}
		else {
			temp++;
			move1 = temp;
			move2 = p2;
		}
	}
	if (*move2 == '\0')
		return temp;
	else
		return NULL;
}

int main() {
	char arr1[] = "abbbcdef";
	char arr2[] = "bbc";
	char*ret = my_strstr(arr1, arr2);
	if (ret != NULL)
		printf("%s\n", ret);
	else
		printf("找不到\n");
}

运行结果：

 6.memcpy是复制内存块的函数

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

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

该函数不检查源中是否有任何终止的null字符——它总是精确地复制num个字节。

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

 代码示例：

//模拟实现memcpy
#include <stdio.h>
#include <string.h>
#include <assert.h>

void* my_memcpy(char*p1,const char*p2,int size) {
	assert(p1 && p2);
	char* temp = p1;
	while (size--) {
		*p1 = *p2;
		p1++;
		p2++;
	}
	return temp;
}

int main() {
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	my_memcpy(arr2, arr1, 40);
	for (int i = 0; i < 20; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

运行结果：

7.memmove是移动内存块的函数

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

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

该函数不检查源中是否有任何终止的null字符——它总是精确地复制num个字节。

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

 代码示例：

//模拟实现memmove
#include <stdio.h>
#include <string.h>
#include <assert.h>

void* my_memmove(const void* p1, const void* p2, size_t num) {
	assert(p1 && p2);
	if (p1 < p2) {
		while (num--) {//前向后
			*(char*)p1 = *(char*)p2;
			p1 = (char*)p1 + 1;
			p2 = (char*)p2 + 1;
		}
	}
	else {
		//		//后->前
		while (num--)//20
		{
			*((char*)p1 + num) = *((char*)p2 + num);
		}
	}
}

int main() {
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	//             3 4 5 6 7 6 7 8 9 10
	//             1 2 1 2 3 4 5 8 9 10
	my_memmove(arr1, arr1+2, 20);
	//my_memmove(arr1+2, arr1, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

代码示例：