模拟实现strstr,strcpy,strlen,strcat,strcmp,memcpy,memmove

1，模拟实现strstr

strstr为字符串查找函数，其原型为：

char *strstr( const char *string, const char *strCharSet );

这个函数就是在string中寻找是否含有子字符串strCharSet，寻找过程两个都不需要发生改变，所以将它们声明为const常量。返回值为char *这样可以方便链式访问。代码实现如下：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
char *my_strstr(const char *dest,const char *src)
{
	assert(dest);
	assert(src);
	char *p1 = NULL;
	char *p2 = NULL;
	char *ptr = dest;
	while(*ptr)
	{
		p1 = ptr;
		p2 = src;
		while (*p1 == *p2)
		{
			p1++;
			p2++;
			if (*p2 == '\0')
			{
				return ptr;
			}
		}
		ptr++;
	}
	return NULL;
}
int main()
{
    char arr[20] = "abcdefg";
	char *p = "def";
	char *ret = my_strstr(arr, p);
	if (ret != NULL)
	{
		printf("%p\n", ret);
		printf("%s\n", ret);
	}
	else
	{
		printf("not exist\n");
	}
	system("pause");
	return 0;
}

2，模拟实现strcpy

strcpy是字符串拷贝函数，其原型为：

char *strcpy( char *strDestination, const char *strSource );

这个函数就是将strSource中的字符串拷贝到strDestination中，strSource不会发生改变，所以用const加以修饰。代码实现如下：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
char *my_strcpy(char *dest, const char *src)
{
	assert(dest);
	assert(src);
	char *ret = dest;
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr[20] = "abcde";
	char *p = "xyzw";
	char *ch=my_strcpy(arr, p);
	printf("%s\n", ch);
	system("pause");
	return 0;
}

3，模拟实现strlen

strlen是求取字符串长度的函数，其原型为：

size_t strlen( const char *string );

size_t其实就是无符号整型。string不需要修改，所以应用const保护起来。代码实现如下：

（1）计数器

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
int my_strlen(char *str)
{
	assert(str);
	int count = 0;
	while (*str)
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	char arr[] = "abcdefghi";
	int len=my_strlen(arr);
	printf("%d\n", len);
	system("pause");
	return 0;
}

（2）递归

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
int my_strlen(const char *str)
{
	assert(str);
	if (*str)
	{
		return 1 + my_strlen(str + 1);
	}
	return 0;
}
int main()
{
	char arr[] = "abcdefghi";
	int len=my_strlen(arr);
	printf("%d\n", len);
	system("pause");
	return 0;
}

（3）指针减指针

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
int my_strlen(const char *str)
{
	assert(str);
	const char *p = str;//为了防止通过p修改了str，所以将p设为常量指针
	while (*str)
	{
		str++;
	}
	return str - p;//指针减指针
}
int main()
{
	char arr[] = "abcdefghi";
	int len=my_strlen(arr);
	printf("%d\n", len);
	system("pause");
	return 0;
}

4，模拟实现strcat

strcat是字符串追加函数，其原型为：

char *strcat( char *strDestination, const char *strSource );

就是将字符串strSource追加在字符串strDestination后面，代码 实现如下：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
char *my_strcat(char *dest, const char *src)
{
	assert(dest);
	assert(src);
	char *ret = dest;
	while (*dest)
	{
		dest++;
	}
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr[20] = "abcd";
	char *p = "efgh";
	char *ch=my_strcat(arr, p);
	printf("%s\n", ch);
	system("pause");
	return 0;
}

5，模拟实现strcmp

strcmp是字符串比较函数，它的原型为：

int strcmp( const char *string1, const char *string2 );

按位比较字符串中每个字符的ASCII码值。如果string1大于string2，则返回1，如果小于则返回-1，相等返回0。代码实现如下：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
int my_strcmp(const char *dest, const char *src)
{
	assert(dest);
	assert(src);
	while (*dest == *src)
	{
		if (*dest =='\0')
		{
			return 0;
		}
		dest++;
		src++;
	}
	return *dest - *src;
}
int main()
{
	const char *p1 = "abcdef";
	const char *p2 = "aef";
	int ret = my_strcmp(p1, p2);
	if (ret == 0)
	{
		printf("p1==p2\n");
	}
	else if (ret >0)
	{
		printf("p1>p2\n");
	}
	else
	{
		printf("p1<p2\n");
	}
	system("pause");
	return 0;

6，模拟实现memcpy

memcpy是内存拷贝函数，它的原型是：

void *memcpy( void *dest, const void *src, size_t count );

它从源src所指的内存空间的起始位置开始拷贝count个字节到目标dest所指的内存地址的起始位置中，函数返回指向dest的指针。src和dest不一定是数组，任意可读写的空间都可以。代码实现如下：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
void *my_memcpy(void *buf1, const void *buf2, int count)
{
	assert(buf1);
	assert(buf2);
	void *ret = buf1;
	char *dest = (char *)buf1;
	char *src = (char *)buf2;
	char *ptr = dest;
	while (count--)
	{
		*dest++ = *src++;
	}
	return buf1;
}
int main()
{
	char arr1[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	char arr2[10] = { 0 };
	int i = 0;
    my_memcpy(arr1, arr2, 10);
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", arr1[i]);
	}
	system("pause");
	return 0;
}

注意：

src和dest所指的内存区域有可能重叠，但是memcpy不能保证src所在重叠区域在拷贝之前不被覆盖。使用memmove可以解决这个问题。

7，模拟实现memmove

memmove也是内存拷贝函数，它的原型是：

void *memmove( void *dest, const void *src, size_t count );

由str复制count个字节到dest中，，如果目标区域和源区域有重叠的部分，memmove能够保证src在被覆盖之前将重叠部分的字节拷贝到dest中。代码实现如下：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
void *my_memmove(void *buf1, const void *buf2, int count)
{
	assert(buf1);
	assert(buf2);
	void *ret = buf1;
	char *dest = (char *)buf1;
	char *src = (char *)buf2;
	if ((dest > src) && (dest < src + count))
	{
		while (count--)
		{
			*(dest+count) = *(src+count);
		}
	}
	else
	{
		while (count--)
		{
			*dest++ = *src++;
		}
	}
	return ret;
}
int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	my_memmove(arr + 5, arr + 2, 12);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d\n", arr[i]);
	}
	system("pause");
	return 0;
}

本文出自 “Stand out or Get out” 博客，请务必保留此出处http://jiazhenzhen.blog.51cto.com/10781724/1718721