————– 1模拟实现strcpy—————
strcpy函数是将源字符串复制到目标字符串的函数
strcpy函数的思路就是，它是一个字符串，有\0作为结束标志，那么可以用\0作为突破点和条件，具体代码如下：
char* my_strcpy(char *dest, const char *src)
{
assert(dest);
assert(src);
char *ret = src;
while ((*dest++ = *src++))
{
;
}
return ret;
}
————– 1模拟实现strcat—————
strcat函数是将一一个字符串连接到目标字符串的函数
strcat函数的思路是目标字符串有‘\0’结束，那么可以用’\0’作为第一个判断条件，然后源字符串的结束标志‘\0’可以作为第二个判断条件，具体代码如下：
#include
#include
void my_strcat(char *dest, char *src)
{
assert(dest);
assert(src);
while (*dest)
{
dest++;
}
while (*dest++ = *src++)
{
;
}
}
int main()
{
char arr1[20] = { "abcd" };
char arr2[] = { "efgh" };
my_strcat(arr1, arr2);
printf("%s", arr1);
return 0;
}
————– 3模拟实现strstr—————
strstr函数是在字符串中查找子字符串的函数，如果有反悔所在位置，没有返回NULL。
strstr函数的思路就是从母字符串中的第一个字符开始查找，然后一个一个查找，直到子字符串结束或者母字符串结束，具体代码如下：
char* my_strstr(const char *str1, const char *str2)
{
assert(str1);
assert(str2);
if (*str2 == '\0')
{
return NULL;
}
char *p1 = (char*)str1;
char *p2 = (char*)str2;
char *tmp = NULL;
while (*p1)
{
tmp = p1;
while ((*p1&&*p2) && (*p1 == *p2))
{
p1++;
p2++;
}
if (*p2 == '\0')
{
return tmp;
}
p1++;
}
return NULL;
}
————– 4模拟实现strchr—————
strchr函数是在字符串中查找一个字符，如果有返回所在位置，如果没有返回null。
strchr函数的思路是从字符串的首字符开始查找，如果找到就返回所在位置，如果找不到就继续查找，一直带字符串结束‘\0’为止。具体代码如下：
#include
#include
char *my_strchar(const char *str, const char a)
{
char *p = (char*)str;
while (*p)
{
if (*p == a)
return p;
p++;
}
return NULL;
}
int main()
{
char arr1[] = { "assdfg" };
char a = 'd';
char *ret = my_strchar(arr1, a);
printf("%s", ret);
return 0;
}
————– 4模拟实现strcmp————–
strcmp函数是比较两个字符串的大小，如果目标字符串大于要比的字符串，返回一个正数，等于返回0，小于返回负数。
strcmp函数的思路就是将两个字符串的字符逐个比较，如果比较的字符相同，那么继续比较下一个字符，一直循环到一个字符串结束‘\0’结束，如果字符不同，那么直接结束比较。具体代码如下：
#include
#include
int my_strcmp(const char *dest, const char *src)
{
assert(dest);
assert(src);
int ret = 0;
while (!(ret = (*(unsigned char*)dest - *(unsigned char*)src))&&*src)
{
dest++;
src++;
}
return ret;
}
int main()
{
char arr1[] = { "asdfg" };
char arr2[] = { "asdfgh" };
int ret = my_strcmp(arr1, arr2);
printf("%d", ret);
return 0;
}
———— 6模拟实现memcpy———–
memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。
memcpy函数并不复杂，通过使用count计数器就可以拷贝n字节到dest中，需要注意的是，在函数调用参数设计中，要注意函数参数的类型，应该是void类型，然后在函数内部强制转换成char*类型。具体代码如下：
#include//模拟实现memcpy
void* my_memcpy(void* dest, void *src, int count)
{
char* pdest = (char*)dest;
char* psrc = (char*)src;
while (count--)
{
*pdest++ = *psrc++;
}
return dest;
}
int main()
{
int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
my_memcpy(arr1+3, arr1, 20);
return 0;
}
———— 7模拟实现memmove———-
memmove用于从src拷贝count个字节到dest，如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。但复制后src内容会被更改。但是当目标区域与源区域没有重叠则和memcpy函数功能相同
memmove函数的思路和memcpy函数基本相同，只不过memmove不存在覆盖，那么就可以通过判断dest和src的位置来判断是从前到后拷贝还是从后向前拷贝。第一种方法是：如果dest在src前边，那么就需要从前向后拷贝，如果dest在src后边从后向前拷贝，就不存在覆盖。第二种方法是：判断dest是否在src和src+count之间，如果在，那就从后向前拷贝，其余的从前向后拷贝，就不存在覆盖内容，具体代码如下：
#include//模拟实现memmove函数。
void* my_memmove(void* dest, const void*src, int count)
{
char* pdest = (char*)dest;
char* psrc = (char*)src;
if ((pdest > psrc) && (pdest < (psrc + count)))
{
while (count--)
{
*(pdest + count) = *(psrc + count);
}
}
else
{
while (count--)
{
*pdest++ = *psrc++;
}
}
return dest;
}
int main()
{
int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
my_memmove(arr1+3,arr1 , 20);
int i = 0;
for (i = 0; i < 9; i++)
{
printf("%d", arr1[i]);
}
return 0;
}
———— 8模拟实现memset———-
函数原型：void* memset (void * ptr, int ch, size_t num );
参数解释：ptr:目标地址 value:要替换的值， num:要替换的大小，单位（字节）
函数功能：将s中当前位置后面的n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s。
void* Memset(void* ptr, int ch, size_t num)
{
assert(ptr);
char* dest = (char*)ptr;
while (num--)
{
*dest = ch;
dest++;
}
return (void*)dest;
}
void test_memset()
{
char a[10] = { 0 };
Memset(a, 'a', 10);
for (int i = 0; i < 10; i++)
{
cout << a[i] << " ";
}
}
