模拟实现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