C语言:字符串函数(strcpy,memcpy等)模拟实现

时间:2022-09-14 20:38:37

不受限制的字符串函数(strcpy,strcat,strcmp)

(1)字符串复制
C语言标准库函数strcpy,把从src地址开始且含有’\0’结束符的字符串复制到以dst开始的地址空间。
模拟实现strcpy:

char *my_strcpy(char *dst,const char*src)
{
char *p = dst;
assert(dst!=NULL&&src!=NULL);
while((*dst++ = *src++)!='\0');
return p;
}
int main()
{
char str1[] = "abc";
char str2[] = "defg";
printf("将str1内存中内容拷贝到str2中:\n");
my_strcpy(str2,str1);
printf("%s\n",str2);
return 0;
}

(2)字符串连接
strcat是把src所指字符串添加到dest结尾处(覆盖dest结尾处的‘\0’),src和dst所指内存区域不可以重叠,所以dst必须有足够的空间来容纳。最后结果返回的是指向dst的指针。

char *my_strcat(char *dst,const char *src)
{
char *p = dst;
assert(dst&&src);
while(*dst)
{
dst++;
}
while(*dst++ = *src++)
{
;
}
return p;
}
int main()
{
char str1[10] = "AB";
char str2[] = "EFGH";
printf("将str2拼接到str1后面:\n");
my_strcat(str1,str2);
printf("%s\n",str1);
return 0;
}

(3)字符串比较
比较两个字符串涉及对两个字符串对应的字符逐个比较,直到发现不匹配为止。
如果str1大于str2返回1,如果str2大于str1返回-1。

int my_strcmp(const char* str1,const char* str2)
{
assert(str1&&str2);
while(*(str1) ==*(str2))
{
if(*str1 == '\0')
return 0;
str1++;
str2++;
}
if(*str1 >*str2)
return 1;
else
return -1;
}
int main()
{
char str1[] = "AB";
char str2[] = "ABCDEFG";
printf("将str1与str2比较,大于输出1,小于输出-1,等于输出0\n");
printf("结果为:%d\n", my_strcmp(str2, str1));
return 0;
}

长度受限的字符串函数 (strncpy,strncat,strncmp)

标准库还包括了一些函数,这些函数接受一个显示的长度参数,用于限定进行复制或比较的字符数,可以防止难以预料的长字符串从它们的目标数组溢出。
(1)strncpy

char *my_strncpy(char *dst,const char *src,size_t n)
{
char *p=dst;
assert(dst!=NULL&&src!=NULL);
while(n)
{
if((*dst++ =*src++)=='\0')
break;
n--;
}
return 0;
}

(2)strncat

char* my_strncat(char *dst,const char *src,size_t n)
{
char *p = dst;
assert(dst&&src);
while(*dst)
{
dst++;
}
while(n--)
{
*dst++ = *src++;
}
*dst='\0';
return p;
}

(3)strncmp

int my_strncmp(const char* str1, const char* str2,int n)  
{
assert(str1);
assert(str2);
while (n)
{
if (*str1 == *str2)
{
str1++;
str2++;
}
else
{
return *str1 - *str2;
}
n--;
}
return 0;
}

内存操作

(1)模拟实现内存操作函数memcpy
memcpy是内存拷贝函数,功能是从源src所指的内存地址的起始位置开始拷贝num个字节到目标dst所指的内存地址的起始位置中

void *my_memcpy(void *dst,const void *src,size_t num)
{
void *ret = dst;
while(num--)
{
*(char*)dst = *(char *)src;
dst = (char*)dst + 1;
src = (char*)src + 1;
}
return ret;
}
int main()
{
char str1[] = "abccde";
char str2[] = "1234";
printf("%s\n",my_memcpy(str1,str2,3));
return 0;
}

(2)模拟实现内存操作函数memcpy
memmove用于从src拷贝count个字节到dst,如果目标区域和源区域有重叠的话,memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。但复制后src内容会被更改。但是当目标区域与源区域没有重叠则和memcpy函数功能相同。

void * my_memmove(void * dst, const void * src, size_t num)  
{
void *ret = dst;
if (dst<src || ((char *)dst>(char*)src + num))
{
while (num--)
{
*(char*)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char*)src + 1;
}
}
else
{
dst = (char*)dst + num - 1;
src = (char*)src + num - 1;
while (num--)
{
*(char*)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char*)src + 1;
}
}
return ret;
}
int main()
{
char arr[10] = "abcdefg";
char arr0[10] = "abcdefg";
char arr1[10] = { 0 };
my_memmove(arr + 1, arr, 4);
my_memmove(arr1, arr0, 4);
printf("内存覆盖情况:%s\n", arr + 1);
printf("正常情况:%s\n", arr1);
}