内存函数和字符函数的函数实现(strstr)(strlen)(strcpy)(strcat)(strcmp)(memcpy)(memmove)(memset)

最新推荐文章于 2024-04-25 16:11:58 发布

原创最新推荐文章于 2024-04-25 16:11:58 发布 · 158 阅读

1 ·

CC 4.0 BY-SA版权

C学习心得专栏收录该内容

15 篇文章

订阅专栏

这篇博客介绍了C语言中常用的字符串处理函数，包括strlen用于计算字符串长度，strcpy用于复制字符串，strcat用于连接字符串，strcmp用于比较字符串，strstr用于查找子串，以及内存操作函数memcpy, memmove和memset。这些函数是C语言编程的基础，对于理解和操作字符串及内存管理至关重要。

strlen

求字符数组的长度的函数，下面用了3中方法实现了strlen

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

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

int my_strlen(char * str)
{
	char * start = str;
	while (*str)
	{
		str++;
	}
	while (*str++);
	str--;
	return str - start;
}

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

int main()
{
	char arr[] = "hello world";
	int ret = my_strlen(arr);
	printf("string_length = %d\n", ret);
	return 0;
}

strcpy

这是一个字符串拷贝的函数，可以将一个字符数组的内容移到另一个字符数组当中

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>


char* my_strcpy(char * dest, const char* src)
{
	char * start = dest;
	while (*dest++ = *src++);
	//while (*src != '\0')
	//{
	//	*dest = *src;
	//	src++;
	//	dest++;
	//}
	//*dest = *src;//添加最后一个\0
	return start;
}

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

strcat

这是一个字符追加函数，可以将两个字符数组的内容拼接起来，注意该函数不能自己追加自己，这样会导致死循环

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

char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* start = dest;
	while (*dest++);
	dest--;
	while (*dest++ = *src++);
	return start;
}


int main()
{
	char arr1[20] = "hello ";
	char arr2[] = "world";
	printf("%s\n", my_strcat(arr1, arr2));
	return 0;
}

strcmp

这是字符比较函数，可以判断两个祖父数组的字符谁大谁小

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

int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str2 == '\0')
			return 0;
		str1++;
		str2++;
	}
	//if (*str1 > *str2)
	//	return 1;
	//else
	//	return -1;
	return *str1 - *str2;
}

int main()
{
	char arr1[] = "hello world";
	char arr2[] = "hello world";
	if (my_strcmp(arr1, arr2) == 0)
	{
		printf("相同\n");
	}
	else
	{
		printf("不相同\n");
	}
	return 0;
}

strstr

这是在字符数组当中找字符数组，可以说就是大串中是否能找到小串，如果能找到就返回子串的地址，若不能就返回NULL

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

char * my_strstr(const char* fatherstr, const char* sonstr)
{
	assert(fatherstr && sonstr);
	if(*sonstr == '\0')
		return NULL;
		
	const char* prev = fatherstr;
	while (*prev)
	{
		const char* fp = prev;
		const char* sp = sonstr;
		while (*fp == *sp && *fp && *sp)
		{
			fp++;
			sp++;
		}
		if (*sp == '\0')
			return prev;
		prev++;
	}
	return NULL;
}

int main()
{
	char arr1[] = "abbbcdef";
	char arr2[] = "bcdads";
	if (my_strstr(arr1, arr2) != NULL)
	{
		printf("找到了\n");
	}
	else
	{
		printf("没找到\n");
	}
	return 0;
}

为了弥补只有字符函数的空档没所以又有了内存函数，这些函数直接对内存操作，所以适用于各种类型的变量和数组。

memcpy

这是内存拷贝函数，作用和strcpy差不多，都是讲内容拷贝。

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

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

int main()
{
	int arr1[20] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	int sz = sizeof(arr1) / sizeof(arr1[0]);

	my_memcpy(arr2, arr1, sizeof(arr1[0])*sz);

	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr2[i]);
	}

	return 0;
}

memmove

因为有时memcpy可能不能完整拷贝数组内容，所以在memcpy的基础上又加上了一些弥补

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

void * my_memmove(void * dest, const void *src, int count)
{
	assert(dest && src);
	void* start = dest;
	if (src > dest)
	{
		while (count--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else if (src < dest)
	{
		while (count--)
		{
			*((char*)dest + count) = *((char*)src + count);
		}
	}
	return start;
}

int main()
{
	int arr1[20] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	int sz = sizeof(arr1) / sizeof(arr1[0]);

	my_memmove(arr1 + 4, arr1, sizeof(arr1[0]) * 10);

	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr1[i]);
	}

	return 0;
}

memset

该函数是对内存的内容进行一些修改，但是注意他只能对字节进行修改，如果像int类型的变量就不能一次性改完

#include <memory.h>
#include <stdio.h>

int main()
{
	char arr[] = "********";
	memset(arr, '#', 4);
	printf("%s\n", arr);
	return 0;
}