模拟实现库函数

最新推荐文章于 2022-05-09 10:13:09 发布
最新推荐文章于 2022-05-09 10:13:09 发布
阅读量3.8k 收藏 1
点赞数
分类专栏： C 文章标签： c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38121874/article/details/72808829
版权

1、模拟实现strcpy
//src是源字符串，不可改变，故用const修饰;char*（指向char的指针）
char* MyStrcpy(char *dst, const char *src)
{
   //判断指针是否为空，保证代码的健壮性
assert（(NULL != dst） && (NULL != src));
   //复制后，dst的地址应该是不变的，所以要保存dst的原地址
   char *ret = dst;
   //注意是*src指向的值不等于'\0，可省略不写
   while (*(dst++) = *(src++) != '\0')
{
;
}
return ret;
}

2、模拟实现strlen
1)非递归
size_t my_strlen(const char *str)
{
int count = 0;
assert(NULL != str);
while('\0' != *str)
{
count++;
str++;
}
return count;
}
2）size_t my_strlen(const char *str)
  {
      char *p = str;
      while(‘\0’ != *str)
      {
          str++;
       }
      return p - s;
}

3）递归
第一步：用assert宏做入口校验。（需注意！）
第二步：判断参数指针指向的值是否为零，如果是，那么表明这是一个空字符串或者是字符串的结束标志。
第三步：如果参数指针指向的值不为零，则说明指针指向的值是一个字符串。既然这个指针存放了一个字

符，那就计数为1，指针加1在调用其本身。如此循环到字符串的结束标志符‘\0’时，递归停止。
size_t my_strlen(const char *str)
{
assert(NULL != str);
if (‘\0’== *str)
return 0;
else
return (1 + my_strlen(str+1));
//assert(NULL != str);
//return (‘\0’!= *str) ? (1 + my_strlen(str+1)) : 0;
}

3、模拟实现strcat
char *my_strcpy(char *dst, const char *src)
{
char *ret = dst;
assert(NULL != dst);
assert(NULL != src);
while ('\0' != *dst)
{
dst++;
}
while (*dst++ = *src++)
{
;
}
return ret;
}

4、模拟实现strcmp
1)
int my_strcmp(const char *src, const char *dst)
{
while (*src == *dst)
{
if ('\0' == *src)
{
return 0;
}
src++;
dst++;
}
return *src - *dst;
}
2)
int my_strcmp(const char *src, const char *dst)
{
int ret = 0;
//当两个字符串的字符相等时，执行while循环，而*dst是为了确保相等的这个字符不为\0
//其中，*dst与1）中的if句功能相当
while (!(ret = *(unsigned char*)src) == *(unsigned char*)dst && *dst)
{
src++;
dst++;
}
if (ret < 0)
return -1;
else if (ret > 0)
return 1;
return ret;
}

5、模拟实现strstr
    使用strstr函数可以在一个字符串中查找一个子串。它的原型如下：
         char *my_strstr(char const *str1, char const *str2)
strstr函数的实现方式：这个函数在str1中查找整个str2第一次出现的起始位置，并返回一个

指向该位置的指针。如果str2没有完整的出现在str1中的任何地方，函数将返回一个NULL指针。

如果第2个参数是一个空字符串，函数就返回str1.
# include<stdio.h>
# include<stdlib.h>
# include<assert.h>

char *my_strstr(const char *str1, const char *str2)
{
char *s1 = str1;
char *s2 = str2;
char *cp = s1;
assert(str1);
assert(str2);
if ('\0' == *str2)
{
return str1;
}
while ('\0' != *cp)
{
s1 = cp;
s2 = str2;
while (*s1 && *s2 && (*s1 == *s2))
{
s1++;
s2++;
}
if ('\0' == *s2)
{
return cp;
}
cp++;
}
return NULL;
}

int main()
{
char *str1 = "abbbcde";
char *str2 = "0";
char *ret = my_strstr(str1, str2);
if (0 == ret)
{
printf("不存在!\n");
}
else
{
printf("%s\n", ret);
}
system("pause");
return 0;
}
运行结果：



注：
str1表字符串的原始位置，str2表子串的原始位置，cp表在字符串“查找”中的原始位置，

s1表在字符串查找中的“顺序”位置，s2表子串在查找中的“顺序”位置。每次查找完，

s2返回str2原始位置重新查找，s1返回str1查找中的位置重新查找即cp的位置。

6、模拟实现memcpy
   memcpy是内存拷贝函数，拷贝的是内存块，对于长度大于一个字节的数据，要确

保把数量和数据类型的长度相乘，即count*sizeof(arr[0])。它的原型如下：
   void *my_memcpy(void *dst, const void *src, size_t count)
   使用memcpy函数，可以从src的起始位置复制count个字节到dst的内存起始位置，

能复制任何类型的值，
# include <stdio.h>
# include <stdlib.h>
# include <assert.h>

void *my_memcpy(void *dst, const void *src, size_t count)
{
void *ret = dst;
assert(dst);
assert(src);
while (count--)
{
*(char *)dst = *(char *)src;//void*类型指针不能直接解引用运算
dst = (char *)dst + 1;//要强制类型转换
src = (char *)src + 1;
}
return ret;
}

//void *my_memcpy(void *dst, const char *src, size_t count)
//{
// char *pdst = dst;
// char *psrc = src;
// assert(dst);
// assert(src);
// while(count--)
// {
// *pdst++ = *psrc++;
// }
// return dst;
//}

int main()
{
int arr1[50] = { 0 };
int arr2[] = { 1, 2, 3, 4, 5 };
int *ret = my_memcpy(arr1, arr2, 4);
int i = 0;
for (i = 0; i < (sizeof(arr2)/4); i++)
{
printf("% d", ret[i]);
}
printf("\n");
system("pause");
return 0;
}
运行结果为：




7、模拟实现memmove
   memmove函数的行为和memcpy差不多，只是它的源和目标操作数可以重叠。

使用memove函数把源操作数复制到一个临时位置，这个临时位置不会与源或

目标操作数重叠，然后再把它再把从临时位置复制到目标操作数。
# include <stdio.h>
# include <stdlib.h>
# include <assert.h>

void *my_memmove(void *dst, const void *src, size_t count)
{
void *ret = dst;
assert(dst);
assert(src);
//从前往后
if (dst <= src)
{
while (count--)
{
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
}
//从后往前
else
{
while (count--)
{
*((char *)dst + count) = *((char *)src + count);
}
}
return ret;
}

int main()
{
int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int arr2[] = { 5, 4, 3, 2, 1 };
int i = 0;
int ret = my_memmove(arr1 + 2, arr1 + 3, 20);
for (i = 0; i < (sizeof(arr1) / 4); i++)
{
printf("% d", arr1[i]);
}
printf("\n");
system("pause");
return 0;
}
运行结果：

注：要先判断src和dst的位置关系，如果dst在src的前面，那么从前往后

复制；如果dst在src的后面，那么从后往前复制。1、模拟实现strcpy

//src是源字符串，不可改变，故用const修饰;char*（指向char的指针）

char* MyStrcpy(char *dst, const char *src)

{

   //判断指针是否为空，保证代码的健壮性

assert（(NULL != dst） && (NULL != src));

   //复制后，dst的地址应该是不变的，所以要保存dst的原地址

   char *ret = dst;

   //注意是*src指向的值不等于'\0，可省略不写

   while (*(dst++) = *(src++) != '\0')

{

;

}

return ret;

}

2、模拟实现strlen

1)非递归

size_t my_strlen(const char *str)

{

int count = 0;

assert(NULL != str);

while('\0' != *str)

{

count++;

str++;

}

return count;

}

2）size_t my_strlen(const char *str)

  {

      char *p = str;

      while(‘\0’ != *str)

      {

          str++;

       }

      return p - s;

}

3）递归

第一步：用assert宏做入口校验。（需注意！）

第二步：判断参数指针指向的值是否为零，如果是，那么表明这是一个空字

符串或者是字符串的结束标志。

第三步：如果参数指针指向的值不为零，则说明指针指向的值是一个字符串。

既然这个指针存放了一个字符，那就计数为1，指针加1在调用其本身。如此

循环到字符串的结束标志符‘\0’时，递归停止。

size_t my_strlen(const char *str)

{

assert(NULL != str);

if (‘\0’== *str)

return 0;

else

return (1 + my_strlen(str+1));

//assert(NULL != str);

//return (‘\0’!= *str) ? (1 + my_strlen(str+1)) : 0;

}

3、模拟实现strcat

char *my_strcpy(char *dst, const char *src)

{

char *ret = dst;

assert(NULL != dst);

assert(NULL != src);

while ('\0' != *dst)

{

dst++;

}

while (*dst++ = *src++)

{

;

}

return ret;

}

4、模拟实现strcmp

1)

int my_strcmp(const char *src,const char *dst)

{

while (*src == *dst)

{

if ('\0' == *src)

{

return 0;

}

src++;

dst++;

}

return *src - *dst;

}

2)

int my_strcmp(const char *src,const char *dst)

{

int ret = 0;

//当两个字符串的字符相等时，执行while循环，而*dst是为了确保相等的这个字符不为\0

    //其中，*dst与1）中的if句功能相当

while (!(ret = *(unsigned char*)src) == *(unsigned char*)dst && *dst)

{

src++;

dst++;

}

if (ret < 0)

return -1;

else if (ret > 0)

return 1;

return ret;

}

5、模拟实现strstr

    使用strstr函数可以在一个字符串中查找一个子串。它的原型如下：

         char *my_strstr(char const *str1, char const *str2)

strstr函数的实现方式：这个函数在str1中查找整个str2第一次出现的起始位置，

并返回一个指向该位置的指针。如果str2没有完整的出现在str1中的任何地方，

函数将返回一个NULL指针。如果第2个参数是一个空字符串，函数就返回str1.

# include<stdio.h>

# include<stdlib.h>

# include<assert.h>

 

char *my_strstr(const char *str1,const char *str2)

{

char *s1 =str1;

char *s2 =str2;

char *cp = s1;

assert(str1);

assert(str2);

if ('\0' == *str2)

{

return str1;

}

while ('\0' != *cp)

{

s1 = cp;

s2 = str2;

while (*s1 && *s2 && (*s1 == *s2))

{

s1++;

s2++;

}

if ('\0' == *s2)

{

return cp;

}

cp++;

}

return NULL;

}

 

int main()

{

char *str1 ="abbbcde";

char *str2 ="0";

char *ret = my_strstr(str1, str2);

if (0 == ret)

{

printf("不存在!\n");

}

else

{

printf("%s\n", ret);

}

system("pause");

return 0;

}

运行结果：

 

注：

str1表字符串的原始位置，str2表子串的原始位置，cp表在字符串“查找”中的原始位置，

s1表在字符串查找中的“顺序”位置，s2表子串在查找中的“顺序”位置。每次查找完，s2

返回str2原始位置重新查找，s1返回str1查找中的位置重新查找即cp的位置。

6、模拟实现memcpy

   memcpy是内存拷贝函数，拷贝的是内存块，对于长度大于一个字节的数据，要确保

把数量和数据类型的长度相乘，即count*sizeof(arr[0])。它的原型如下：

   void *my_memcpy(void *dst,const void *src,size_t count)

   使用memcpy函数，可以从src的起始位置复制count个字节到dst的内存起始位置，能复制任何类型的值，

# include <stdio.h>

# include <stdlib.h>

# include <assert.h>

 

void *my_memcpy(void *dst,const void *src,size_t count)

{

void *ret =dst;

assert(dst);

assert(src);

while (count--)

{

*(char *)dst = *(char *)src;//void*类型指针不能直接解引用运算

dst = (char *)dst + 1;//要强制类型转换

src = (char *)src + 1;

}

return ret;

}

 

//void *my_memcpy(void *dst, const char *src, size_t count)

//{

//char *pdst = dst;

//char *psrc = src;

//assert(dst);

//assert(src);

//while(count--)

//{

//*pdst++ = *psrc++;

//}

//return dst;

//}

 

int main()

{

int arr1[50] = { 0 };

int arr2[] = { 1, 2, 3, 4, 5 };

int *ret = my_memcpy(arr1, arr2, 4);

int i = 0;

for (i = 0; i < (sizeof(arr2)/4); i++)

{

printf("% d", ret[i]);

}

printf("\n");

system("pause");

return 0;

}

运行结果为：

 

 

7、模拟实现memmove

   memmove函数的行为和memcpy差不多，只是它的源和目标操作数可以重叠。

使用memove函数把源操作数复制到一个临时位置，这个临时位置不会与源或

目标操作数重叠，然后再把它再把从临时位置复制到目标操作数。

# include <stdio.h>

# include <stdlib.h>

# include <assert.h>

 

void *my_memmove(void *dst,const void *src,size_t count)

{

void *ret =dst;

assert(dst);

assert(src);

//从前往后

if (dst <=src)

{

while (count--)

{

*(char *)dst = *(char *)src;

dst = (char *)dst + 1;

src = (char *)src + 1;

}

}

//从后往前

else

{

while (count--)

{

*((char *)dst +count) = *((char *)src +count);

}

}

return ret;

}

 

int main()

{

int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

int arr2[] = { 5, 4, 3, 2, 1 };

int i = 0;

int ret = my_memmove(arr1 + 2, arr1 + 3, 20);

for (i = 0; i < (sizeof(arr1) / 4); i++)

{

printf("% d", arr1[i]);

}

printf("\n");

system("pause");

return 0;

}

运行结果：

 

注：要先判断src和dst的位置关系，如果dst在src的前面，那么从前往后复制；

如果dst在src的后面，那么从后往前复制。

编程鸟
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STM8S003 IAR环境库函数模拟串口
02-06
在IAR环境中，用库函数实现STM8S003单片机的模拟串口功能，用普通IO口作为串口，可以通过中断方式接收数据，也可以通过查询方式接收数据。9600波特率测试。
C语言strcpy函数详解
最新发布
2301_79180143的博客
09-07 5167
strcpy函数是C语言中的一个字符串复制函数，将源字符串'\0'之前的字符拷贝到目标字符串中，头文件为#include，其原型为：char* strcpy(char* dest, const char* src);
期末复习——基础题集 pta c语言
m0_46553277的博客
03-03 9452
5-7 本题目用指针变量输入、输出数组arrA的元素值。 #include <stdio.h> int main(void) { int *ptr, arrA[5]; //读入数组元素 for ( ptr=arrA; ptr<arrA+5; ptr++) { scanf("%d",ptr); } //输出数组元素 ptr=arrA; for(; ptr<arrA+5; ptr++)
C语言-用字符数组实现Strcpy()
qq_63108921的博客
05-09 603
#include<stdio.h> void myStrcpy (char dstStr[], char srcStr[]); int main() { char a[80], b[80]; printf("Please enter a string:"); gets(a); MyStrcpy(b, a); printf("The copy is:"); puts(b); return 0; } void myStrcpy (cha.
成信大2021自动化专业-平时自主学习-C语言改错题解题参考-整理第06页
fhzheng for c java javascript sql html css
12-21 1893
文章目录第06页题面如下：题解如下：D1033.cD1034.cD1035.cD1036.cD1037.cD1038.cD1039.cD1040.cD1041.cD1042.c 第06页 题面如下： 题解如下： D1033.c 原文件 /* 排序字符串，若输入：this test terminal，以下程序的输出结果为： terminal test this */ #include<stdio.h> #include<string.h> #define MAXLINE 20
C语言-指针-用字符指针实现函数Strcpy()
qq_63108921的博客
05-09 1385
#include<stdio.h> void MyStrcpy (char *dsStr, const char *srcStr); int main() { char a[80], b[80]; printf("Please enter a string:"); gets(a); MyStrcpy(&b, &a); printf("The copy is:"); puts(b); return 0; } void .
C语言模拟实现Linux文件系统
09-12
C语言模拟实现Linux文件系统 1、在内存中开辟一块空间来模拟文件系统的运行，不读写硬盘。 2、面向单用户、单任务，不考虑并发，不考虑文件属主、组等概念。 3、程序开始后，初始化并接收用户输入。若输入”enter”...
基于stm32库函数MAX31865实现.rar
07-06
基于stm32库函数MAX31865实现.rar
fackAchieve:手写ES6高级函数，手写Promise，模拟数据结构 ,手写常用工具库函数及框架源码模拟实现
05-14
手写 es6 函数，Promise 特性，lodash 库的函数实现,模拟 vue,React 等前端框架的实现和原理的理解。 functions 文件夹 手动实现各种函数，包括不限于 ES6 等函数的方法 内容对应表 Array 方法名称(name) 位置...
NXP i.MX RT1052实现FLASH模拟EEPROM【支持RT105X系列控制器_库函数驱动】.zip
05-19
NXP i.MX RT1052驱动程序，库函数驱动。 支持RT105X系列控制器编译和运行。 项目代码可顺利编译运行~
不调用库函数，模拟实现strcpy函数
Misszhoudandan的博客
11-01 644
//模拟实现strcpy函数 #include #include void My_Strcpy_1(char * des, char * src) { while (*src != '\0')//将src里面'\0'之前的字符拷贝过去 { *des = *src; des++; src++; } *des = *src;//拷贝'\0'到des } void My_St
strcpy函数
weixin_34301132的博客
07-17 64
#include<stdio.h> #include <assert.h> void myStrcpy(char* Dest, const char *Src) { assert((Dest!= NULL)&&(Src!=NULL)); while((*Dest = *Src)!='\0') { ...
C语言实现mystrcpy等函数
sinat_39440759的博客
10-03 3450
 mystrcpy #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; char *mystrcpy(char *ptr, const char *str) { char *tmp = ptr; while((*ptr++ = *str++) != '\n') { continue; }...
模拟实现字符串拷贝
qq_40192867的博客
03-06 163
#include&lt;stdio.h&gt;#include&lt;string.h&gt;#include&lt;stdlib.h&gt;#include&lt;assert.h&gt;char* my_strcpy(char *dest ,const char *src){    char *ret=dest;  assert(dest!=NULL);  assert(src!=NULL);...
模拟实现库函数：strcat
追梦的小蚂蚁
02-27 202
#define _CRT_SECURE_NO_WARNINGS 1 #include&lt;stdio.h&gt; #include&lt;assert.h&gt; char* my_strcat(char* dest, const char *src) { char*tmp = dest; assert(dest != NULL&amp;&amp;src != NULL); ...
2014.3.4-C语言学习小结
weixin_30514745的博客
03-05 167
位操作： 知识点: 1.位运算符 2.位移运算符 1.将指定位设置为12.将指定位设置为03.获取指定位的内容 ==========================复习二进制 1.二进制转换 10--> /2 取余数 1010 2.原码,反码,补码 -1 0xffffffff %d %#x %#o 3.二进制高位和低位 0000 0001 4....
字符串：实现void strCpy(char dstStr[], char srcStr[])。
刘珂的博客
10-11 1353
#include<stdio.h> #include<string.h> int main() { int a[26]={0}; int i; char s[100]; gets(s); for(i=0;i<strlen(s);i++){ a[s[i]-'a']++; } for(i=0;i<26;i++) { if(a[i]!=0){ ...
常见字符串函数的实现过程
qicheng777的博客
07-30 432
一、strlen（）函数求字符串长度，不包括 ‘\0’unsigned int mystrlen( char *s ) { unsigned int len=0; while(*s != '\0') { s++; len++; } return len; }二、字符串追加函数strcat( )：char *mystrcat(ch
字符函数和字符串函数
海盗船长y的博客
02-25 179
目录： 求字符串长度：strlen 长度不受限制的字符串函数 strcpy strcat strcmp 长度受限制的字符串函数介绍 strncpy strncat strncmp 字符串查找 strstr strtok 错误信息报告 strerror 字符操作 内存操作函数 memcpy memmove memset memcmp 1.strlen size_t strlen ( const ...
模拟实现库函数strcpy
07-27
你可以使用以下代码模拟实现库函数strcpy： ```c #include char* strcpy(char* dest, const char* src) { char* p = dest; while (*src) { *dest++ = *src++; } *dest = '\0'; return p; } int main() { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值