字符串函数和内存函数

简介：本文将介绍常使用的字符串函数和内存函数，以及对其进行模拟实现，以便能够更好的理解和使用这些函数

1、常见的字符串函数

常用的字符串函数有strcpy,strcat,strcmp,strncpy,strncat,strncmp,strstr等。这些函数是针对字符串进行操作的，这些函数都需要包含头文件string.h，下面逐步介绍这些函数并尝试模拟实现。

①strcpy函数

strcpy函数是库函数，需要包含头文件string.h，功能是将源地址空间的字符串拷贝到目标空间，要求目标空间要足够大（能够容下源地址空间的字符串），要求原地址空间必须包含'\0'，这是由于strcpy将源地址空间拷贝到目标空间，源地址到的'\0'（包括'\0'）都要拷贝到目标空间。strcpy库函数的参数如下所示，返回类型是char*，拷贝完成返回目标空间的起始地址，该函数第一个参数是目标空间的起始地址，类型是char*，第二个参数是源空间的起始地址类型也是char*。

strcpy模拟实现代码如下：

char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);//保证dest和src不是NULL
	char* ret = dest;
	while (*dest++ = *src++)//将src指向的内容拷贝到dest指向的内容,最后一个'\0'也会拷贝过去，这时循环也会结束
	{
		;
	}
	return ret;//返回目标空间的起始地址
}

测试代码如下：

#include<stdio.h>
#include<assert.h>
char* my_strcpy(char* dest, const char* src)
{
	assert(dest && src);//保证dest和src不是NULL
	char* ret = dest;
	while (*dest++ = *src++)//将src指向的内容拷贝到dest指向的内容,最后一个'\0'也会拷贝过去，这时循环也会结束
	{
		;
	}
	return ret;//返回目标空间的起始地址
}
int main()
{
	char arr1[] = "asdfasdfasd";
	char arr2[] = "heheawe";
	my_strcpy(arr1, arr2);
	printf("%s\n", arr1);
}

strcpy测试结果如下：

② strcat函数

strcat也是库函数，需要包含头文件string.h，功能是在目标空间的'\0'处追加源地址的字符串，要求目标空间必须存在'\0'，源地址空间也需要有'\0'。因为strcat库函数需要找到目标空间的'\0'在这个位置上追加源地址空间的内容，所以源地址空间也需要'\0'，不然没法知道什么时候结束。strcat函数参数如下所示，返回类型也是char*，返回的目标空间的起始地址，第一个参数表示目标空间的地址，第二个参数是源空间的地址。

strcat模拟实现如下：

char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;
	//找到dest的'\0'
	while (*dest)
		dest++;
	//将src中的内容拷贝到src中
	while (*dest++ = *src++)
		;
	return ret;//返回目标空间的起始地址
}

strcat测试代码如下：

#include<stdio.h>
#include<assert.h>
char* my_strcat(char* dest, const char* src)
{
	assert(dest && src);
	char* ret = dest;
	//找到dest的'\0'
	while (*dest)
		dest++;
	//将src中的内容拷贝到src中
	while (*dest++ = *src++)
		;
	return ret;//返回目标空间的起始地址
}
int main()
{
	char arr1[30] = "www";
	char arr2[] = "asdfxs";
	char* ret = my_strcat(arr1, arr2);
	printf("%s\n", arr1);
	printf("%s\n", ret);
	return 0;
}

strcat测试结果如下：

③strcmp函数

strcmp也是库函数，需要包含头文件string.h，是比较两个字符串的大小，其参数如下图所示，返回值是整形，当第一个字符串大于第二个字符串就返回大于0的数，小于就返回小于0的数，等于就返回0。

strcmp模拟实现的代码如下：（模拟实现采用的是当第一个字符串大于第二个字符串就返回1的数，小于就返回-1，等于就返回0）

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

strcmp测试代码如下：

#include<stdio.h>
#include<assert.h>
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == *str2&&*str1=='\0')
			return 0;
		str1++;
		str2++;
	}
	if (*str1 > *str2)
		return 1;
	else
		return -1;
}
int main()
{
	char arr1[] = "asdf";
	char arr2[] = "asd";
	int ret1 = my_strcmp(arr1, arr2);
	printf("%d\n", ret1);
	char arr3[] = "asdf";
	char arr4[] = "asdf";
	int ret2 = my_strcmp(arr3, arr4);
	printf("%d\n", ret2);
	char arr5[] = "asd";
	char arr6[] = "asdf";
	int ret3 = my_strcmp(arr5, arr6);
	printf("%d\n", ret3);
	return 0;
}

strcmp测试结果如下： 

④strncpy函数

strncpy是库函数，是长度受限的，功能与strcpy是一样的，只是多了一个长度，其参数形式如下图所示，返回的是目标空间的起始地址,第一个参数是目标空间的地址，第二个参数是源空间地址，第三个参数表示要拷贝的字节数（要从源空间拷贝多少个字节到目标空间），当num小于源地址空间的字符个数就拷贝num个字符，当num大于源地址空间的字符个数就将源地址空间的字符全拷贝过来不够的就用'\0'来补。

strcpy模拟实现代码如下：

char* my_strncpy(char* dest, const char* src, size_t count)
{
	assert(dest && src);
	char* ret = dest;
	while (count--)
	{
		*dest = *src;
		if (*src)//防止越界，并且当count大于源空间字符数就会用'\0'来给目标空间赋值
			src++;
		dest++;
	}
	return ret;
}

strncpy测试代码如下：

#include<stdio.h>
#include<string.h>
#include<assert.h>
//strncpy--源字符串不够就用'\0'来补，如果够，将源中的count个拷贝到目的地里
char* my_strncpy(char* dest, const char* src, size_t count)
{
	assert(dest && src);
	char* ret = dest;
	while (count--)
	{
		*dest = *src;
		if (*src)
			src++;
		dest++;
	}
	return ret;
}
int main()
{
	char arr1[20] = "xxxxxxxxxxxxx";
	char arr2[] = "cvztvv";
	my_strncpy(arr1, arr2, 8);
	return 0;
}

strncpy测试结果如下：

⑤strncat函数

strncat是库函数，是长度受限的，功能与strcat是一样的，只是多了一个长度，其参数形式如下图所示，返回的是目标空间的起始地址,第一个参数是目标空间的地址，第二个参数是源空间地址，第三个参数表示要追加的字节数（要从源空间追加多少个字节到目标空间里），也是从'目标空间中的\0'处开始追加,如果num小于源空间中的字符数追加num个字符后还会在最后追加一个'\0'，如果num大于源空间中的字符数就会将源空间都追加到目标空间，再在目标后面加一个'\0'

strncat模拟实现代码如下：

char* my_strncat(char* dest, const char* src, size_t count)
{
	assert(dest && src);
	char* ret = dest;
	while (*dest)//找到目标空间的'\0'
		dest++;
	while (count--)
	{
		if (*src != '\0')
		{
			*dest = *src;
			dest++;
			src++;
		}
		else
		{
			*dest = *src;
			return ret;
		}
	}
	*dest = '\0';
	return ret;
}

strncat测试代码如下：

#include<stdio.h>
#include<string.h>
#include<assert.h>
//在dest的'\0'这个位置开始追加，追加count个，并在后面补'\0'，如果count个数大于src字符串的个数将src中的字符加完就结束了
char* my_strncat(char* dest, const char* src, size_t count)
{
	assert(dest && src);
	char* ret = dest;
	while (*dest) // 找到目标空间的'\0'
		dest++;
	while (count--)
	{
		if (*src != '\0')
		{
			*dest = *src;
			dest++;
			src++;
		}
		else
		{
			*dest = *src;
			return ret;
		}
	}
	*dest = '\0';
	return ret;
}
int main()
{
	char arr1[20] = "xxxxxxx\0xxxxxxxxxxxx";
	char arr2[] = "cvztvv";
	my_strncat(arr1, arr2, 8);
	return 0;
}

strncat测试结果如下：

 ⑥strncmp函数

strncmp是库函数，是长度受限的，功能与strcmp是一样的，只是多了一个长度，其参数形式如下图所示，返回的是目标空间的起始地址,第一个参数是目标空间的地址，第二个参数是源空间地址，第三个参数表示要比较的字节数，如果num大于这个str1或者str2，就相当于strcmp，num小于str1或str2的话就依次比较num个字符，相等就返回0，不相等就返回大于0的数或小于0的数（第一个字符串对应的这个字符大于第二个字符串对应的这个字符就返回大于0的数，第一个字符串对应的这个字符小于第二个字符串对应的这个字符就返回小于0的数）。

strncmp模拟实现代码如下： 

int my_strncmp(const char* str1, const char* str2, size_t count)
{
	assert(str1 && str2);
	while (count--)
	{
		if (*str1 != *str2)//不相等就直接返回两者的差
		{
			return *str1 - *str2;
		}
		if (*str1 != 0)
		{
			str1++;
		}
		if (*str2 != 0)
		{
			str2++;
		}
	}
	return 0;
}

strncmp测试代码如下：

#include<stdio.h>
#include<assert.h>
#include<string.h>
//模拟实现strncmp函数
int my_strncmp(const char* str1, const char* str2, size_t count)
{
	assert(str1 && str2);
	while (count--)
	{
		if (*str1 != *str2)//不相等就直接返回两者的差
		{
			return *str1 - *str2;
		}
		if (*str1 != 0)
		{
			str1++;
		}
		if (*str2 != 0)
		{
			str2++;
		}
	}
	return 0;
}
int main()
{
	char str1[] = "asd6";
	char str2[] = "asd6aef";
	int ret = my_strncmp(str1, str2, 6);
	ret= strncmp(str1, str2, 6);
	printf("%d\n", ret);
	return 0;
}

strncmp测试结果如下：

⑦strstr函数

strstr函数是库函数，其功能是找str2是否是str1的子串，如果是子串就返回str1这个字符中第一次出现这个子串的地址，如果不是子串就返回NULL。其参数如下图所示，由于不需要对其进行修改所以都加了const进行修饰。

//对于str1这个字符串每次匹配都要一个指针（进行站岗），另一个指针是用来移动匹配的，str2也是如此，如果这个站岗指针走完还没匹配成功返回NULL，找到就返回这个str1第一次出现str2这个子串的地址其实就是这个站岗指针
const char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	const char* tmp1 = str1;
	const char* tmp2 = str2;
	while (*str1!='\0')//从str1字符串中的头开始匹配
	{
		while (*tmp1 == *tmp2)
		{
			if (*tmp2 == '\0')
				return str1;
			tmp1++;
			tmp2++;
		}
		if (*tmp2 == '\0')
		{
			return str1;
		}
		else
		{
			str1++;
			tmp1 = str1;
			tmp2 = str2;
		}
	}
	//循环完了还没返回那就表示找不到返回NULL
	return NULL;
}

 strstr测试代码如下：

#include<stdio.h>
#include<assert.h>
//对于str1这个字符串每次匹配都要一个指针（进行站岗），另一个指针是用来移动匹配的，str2也是如此，如果这个站岗指针走完还没匹配成功返回NULL，找到就返回这个str1第一次出现str2这个子串的地址其实就是这个站岗指针
const char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	const char* tmp1 = str1;
	const char* tmp2 = str2;
	while (*str1!='\0')//从str1字符串中的头开始匹配
	{
		while (*tmp1 == *tmp2)
		{
			if (*tmp2 == '\0')
				return str1;
			tmp1++;
			tmp2++;
		}
		if (*tmp2 == '\0')
		{
			return str1;
		}
		else
		{
			str1++;
			tmp1 = str1;
			tmp2 = str2;
		}
	}
	//循环完了还没返回那就表示找不到返回NULL
	return NULL;
}

int main()
{
	char arr1[] = "affj";
	char arr2[] = "affj";
	const char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("arr2不是arr1的子串\n");
	}
	else
	{
		printf("arr2是arr1的子串\n");
		printf("%s\n", ret);
	}
	return 0;
}

 strstr测试结果如下:

2、常见的内存函数

常见的内存函数有memcpy，memmove,memset,memcmp等，这些内存函数也需要包含头文件string.h，下面将逐步介绍这些内存函数的功能和模拟实现。

①memcpy函数

memcpy是库函数，这个函数的功能是进行拷贝，将源地址的字符拷贝到目标地址（这两块空间要求不重叠），其功能与strcpy类似，strcpy是针对字符串的，而memcpy函数不论是字符串还是整形，结构体等数据类型都能进行拷贝。memcpy函数的参数如下图所示，可以看到返回类型是void*，第一个参数也是void*，第二个参数也是void*,第三个参数是num（指的是从源拷贝到目标的字节个数）

memcpy函数模拟实现代码如下：

void* my_memcpy(void* dest, void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	while (count--)//一个一个字节的进行拷贝，拷贝count次
	{
		*(char*) dest= *(char*)src;
		dest = (char*)dest+1;
		src = (char*)src+1;
	}
	return ret;
}

memcpy函数测试代码如下：

#include<stdio.h>
#include<assert.h>
void* my_memcpy(void* dest, void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	while (count--)//一个一个字节的进行拷贝，拷贝count次
	{
		*(char*) dest= *(char*)src;
		dest = (char*)dest+1;
		src = (char*)src+1;
	}
	return ret;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[15] = { 0 };
	my_memcpy(arr2, arr1, sizeof(arr1));
	int i = 0;
	for (i = 0; i < sizeof(arr2) / sizeof(arr2[0]); i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

memcpy函数测试结果如下：

 ②memmove函数

memmove是库函数，这个函数的功能是进行拷贝，将源地址的字符拷贝到目标地址（这两块空间可以重叠也可以不重叠），memmove函数不论是字符串还是整形，结构体等数据类型都能进行拷贝。memmove函数的参数如下图所示，可以看到返回类型是void*，第一个参数也是void*，第二个参数也是void*,第三个参数是num（指的是从源拷贝到目标的字节个数）

 memmove函数模拟实现代码如下：

void* my_memmove(void* dest, void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	if (dest > src)//从后往前拷贝
	{
		while (count--)
		{
			*((char*)dest + count) = *((char*)src + count);
		}
	}
	else//从前往后拷贝
	{
		while (count--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	return ret;
}

memmove函数测试代码如下：

#include<stdio.h>
#include<assert.h>
void* my_memmove(void* dest, void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	if (dest > src)//从后往前拷贝
	{
		while (count--)
		{
			*((char*)dest + count) = *((char*)src + count);
		}
	}
	else//从前往后拷贝
	{
		while (count--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	return ret;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr1, arr1 + 3, 5*sizeof(int));
	for (int i = 0; i < sizeof(arr1) / sizeof(arr1[0]); i++)
	{
		printf("%d ", arr1[i]);
	}
	printf("\n");
	int arr2[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr2+3, arr2, 5 * sizeof(int));
	for (int i = 0; i < sizeof(arr2) / sizeof(arr2[0]); i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

 memmove函数测试结果如下：

③memset函数

memset函数是库函数，功能是将ptr指向的内存块的前num个字节设置为value，其函数参数形式如下

 memset函数模拟实现代码如下：

void* my_memset(void* ptr, int value, size_t num)
{
	assert(ptr);
	while (num--)
	{
		*((char*)ptr + num) = value;
	}
	return ptr;
}

memset测试代码如下：

void* my_memset(void* ptr, int value, size_t num)
{
	assert(ptr);
	while (num--)
	{
		*((char*)ptr + num) = value;
	}
	return ptr;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memset(arr1, 0, sizeof(arr1));
	for (int i = 0; i < sizeof(arr1) / sizeof(arr1[0]); i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

memset测试结果如下：

④memcmp函数

memcmp函数是用来比较两个内存空间的大小，按照字节进行比较，比较num个，如果ptr1所指向的这个字节元素大于ptr2所指向的字节元素返回一个正数，如果ptr1所指向的这个字节元素小于ptr2所指向的字节元素返回一个负数，比到num个字节都相等就返回0，其参数如下图所示

 memcmp函数模拟实现代码如下：

int my_memcmp(const void* ptr1, const void* ptr2,size_t num)
{
	assert(ptr1 && ptr2);
	while (num--)
	{
		if (*(char*)ptr1 != *(char*)ptr2)
		{
			return *(char*)ptr1 - *(char*)ptr2;
		}
		ptr1 = (char*)ptr1 + 1;
		ptr2 = (char*)ptr2 + 1;
	}
	return 0;
}

 memcmp函数测试代码如下：

#include<stdio.h>
#include<assert.h>
#include<string.h>
int my_memcmp(const void* ptr1, const void* ptr2,size_t num)
{
	assert(ptr1 && ptr2);
	while (num--)
	{
		if (*(char*)ptr1 != *(char*)ptr2)
		{
			return *(char*)ptr1 - *(char*)ptr2;
		}
		ptr1 = (char*)ptr1 + 1;
		ptr2 = (char*)ptr2 + 1;
	}
	return 0;
}
int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,0 };
	int arr2[] = { 1,2,3,4,4,6,7,8,9,0 };
	int ret=my_memcmp(arr1, arr2, 40);
	printf("%d\n", ret);
	ret = my_memcmp(arr1, arr2, 16);
	printf("%d\n", ret);
	ret = my_memcmp(arr2, arr1, 40);
	printf("%d\n", ret);
	return 0;
}

memcmp函数测试结果如下：

总结：本篇文章介绍了常用的字符串函数和内存函数的参数，功能以及模拟实现,还对这些实现的函数进行了一些简单的测试，基本上与库函数的功能一致，以便更好地在未来编程中理解和使用这些库函数。感谢大家的观看，如有错误不足之处欢迎大家批评指正！！！