AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

C语言—部分库函数的模拟实现

2024-05-22 41
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： C语言—部分库函数的模拟实现

1.模拟实现strcmp

方法一

int my_strcmp(const char* str1, const char* str2) 
{
    while (*str1 && (*str1 == *str2))
 {
        str1++;
        str2++;
 }
    return *(const unsigned char*)str1 - *(const unsigned char*)str2;
}

以上是一个简单的模拟实现strcmp函数的代码，它会逐个字符比较两个字符串的对应位置，直到两个字符串的某个字符不同。如果到达字符串的结尾仍然相等，则两个字符串相等。比较的结果返回值为整数：


  • 如果str1
  • 如果str1>str2，返回正数；
  • 如果str1=str2，返回0。

注意：这里使用了无符号字符指针，是因为以有符号字符指针相减得到的结果会因为符号位的影响而不稳定。


方法二

int my_strcmp (const char * src, const char * dst)
{
  int ret = 0 ;
 assert(src != NULL);
  assert(dest != NULL);
  while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
    ++src, ++dst;
​
  if ( ret < 0 )
    ret = -1 ;
  else if ( ret > 0 )
    ret = 1 ;
​
  return ret ;
}

2.模拟实现 strcat

方法一

#include <stdio.h>
#include <string.h>
 
void mystrcat(char* dest, const char* src) {
    while (*dest) {  // 找到 dest 的末尾
        dest++;
    }
    while (*src) {  // 将 src 中的字符依次复制到 dest 的末尾
        *dest++ = *src++;
    }
    *dest = '\0';  // 在 dest 的末尾添加 '\0'，形成字符串
}
 
int main() {
    char s1[100] = "hello";
    char s2[] = "world";
    mystrcat(s1, s2);
    printf("%s\n", s1);
    return 0;
}

上述代码中，mystrcat 函数的参数包括一个 char 类型的指针 dest 和一个 const char 类型的指针 src，分别表示目标字符串和源字符串。


在函数中，使用 while 循环找到 dest 字符串的末尾，然后再使用 while 循环将 src 中的字符复制到 dest 的末尾，直到遇到 '\0'（字符串结束符）。最后，在 dest 的末尾添加 '\0'，形成完整的字符串。


在 main 函数中，定义了两个字符数组 s1 和 s2，并将 s2 的内容连接在 s1 的末尾。最后输出连接后的字符串。


方法二

char* my_strcat(char* dest, const char* src)
{
 char* ret = dest;
 assert(dest != NULL);
 assert(src != NULL);
 while(*dest)
 {
  dest++;
 }
 while((*dest++ = *src++))
 {
  ;
 }
 return ret;
}

3.模拟实现strstr

方法一

用于查找一个字符串中是否包含另一个子字符串：


char* my_strcat(char* dest, const char* src)
{
 char* ret = dest;
 assert(dest != NULL);
 assert(src != NULL);
 while(*dest)
 {
  dest++;
 }
 while((*dest++ = *src++))
 {
  ;
 }
 return ret;
}

该函数接受两个参数，分别是被查找字符串haystack和要查找的子字符串needle。


函数返回一个指向被查找字符串中第一次出现子字符串的指针，如果没有找到返回NULL。


函数首先获取被查找字符串和子字符串的长度，如果子字符串长度为0，则直接返回被查找字符串的指针。


函数使用两个循环来匹配被查找字符串和子字符串，如果匹配成功则返回被查找字符串中第一次出现子字符串的指针。如果在循环中没有找到子字符串，则返回NULL。


方法二 

char *  strstr (const char* str1, const char* str2)
{
        char* cp = (char*) str1;
        char* s1, *s2;
 
        if ( !*str2 )
            return((char*)str1);
 
        while (*cp)
        {
                s1 = cp;
                s2 = (char*) str2;
 
                while ( *s1 && *s2 && !(*s1-*s2) )
                        s1++, s2++;
 
                if (!*s2)
                        return(cp);
 
                cp++;
        }
 
        return(NULL);
}

4.模拟实现memcpy

方法一

在C语言中，memcpy函数可以用于将一段内存区域的数据复制到另一个内存区域。


下面是一个使用指针实现的memcpy函数：

void *my_memcpy(void *dest, const void *src, size_t n)
 {
    char *pdest = (char *)dest;
    const char *psrc = (const char *)src;
    
    for (size_t i = 0; i < n; i++) 
    {
        *(pdest + i) = *(psrc + i);
    }
    
    return dest;
 }

该函数接受三个参数：目标地址（dest）、源地址（src）以及要复制的字节数（n）。在函数内部，我们首先将目标地址和源地址都转换为char型指针类型，然后通过for循环逐个复制内存中的数据，直到复制了n个字节。最后，函数返回目标地址指针。


需要注意的是，该实现中没有进行边界检查。如果n大于目标地址或源地址所指向的内存区域的大小，那么这个函数就会出现错误。因此，在实际使用中，应该进行边界检查，以确保复制的数据不会越界。


方法二

void * memcpy ( void * dst, const void * src, size_t count)
{
  void * ret = dst;
    assert(dst);
  assert(src);
  /*
   * copy from lower addresses to higher addresses
   */
  while (count--) {
    *(char *)dst = *(char *)src;
    dst = (char *)dst + 1;
    src = (char *)src + 1;
  }
 
  return(ret);
}

5.模拟实现memmove

方法一

memmove()函数用于将指定长度的内存块从一个位置移动到另一个位置，与memcpy()函数不同的是，memmove()函数可以处理源地址和目标地址重叠的情况。


以下是使用C语言模拟实现memmove()函数的代码：


void* memmove(void* dest, const void* src, size_t n)
{
    char* pdest = (char*)dest;
    const char* psrc = (const char*)src;
    char* tmp = NULL;
 
    // 判断是否需要借用临时缓冲区
    if (pdest > psrc && pdest - psrc < n)
    {
        tmp = (char*)malloc(n);
        if (tmp == NULL)
        {
            return NULL;
        }
        memcpy(tmp, psrc, n);
        psrc = tmp;
    }
 
    // 从前往后移动
    if (pdest <= psrc)
    {
        while (n--)
        {
            *pdest++ = *psrc++;
        }
    }
    // 从后往前移动
    else
    {
        pdest += n;
        psrc += n;
        while (n--)
        {
            *--pdest = *--psrc;
        }
    }
 
    // 释放临时缓冲区
    if (tmp != NULL)
    {
        free(tmp);
    }
 
    return dest;
}


这是一个实现内存拷贝函数memmove的代码。其功能是将源内存区域src中的n个字节拷贝到目标内存区域dest中。


该函数的实现方式是通过两个指针pdest和psrc来实现内存的移动。如果目标区域在源区域前面，就从前往后移动，否则就从后往前移动。如果目标区域在源区域前面且两个区域有重叠，就需要借助临时缓冲区。


具体实现步骤如下：


将void类型的dest和src指针强制转换为char类型的指针，方便进行指针位移操作。


判断是否需要借助临时缓冲区。如果目标区域在源区域前面且两个区域有重叠，就需要借助临时缓冲区。这时，先申请一个大小为n的临时缓冲区tmp，并将src中的数据拷贝到tmp中。


根据目标区域在源区域的前后关系，选择从前往后或从后往前移动内存数据。具体的实现方式是用while循环遍历内存区域，并依次将源内存区域的数据拷贝到目标内存区域中，或者反过来。


如果使用了临时缓冲区，需要在操作完成后将其释放。


最后返回目标内存区域dest的指针。


#include <stdio.h>
#include <string.h>
 
void* memmove(void* dest, const void* src, size_t n)
{
    char* pdest = (char*)dest;
    const char* psrc = (const char*)src;
    char* tmp = NULL;
 
    // 判断是否需要借用临时缓冲区
    if (pdest > psrc && pdest - psrc < n)
    {
        tmp = (char*)malloc(n);
        if (tmp == NULL)
        {
            return NULL;
        }
        memcpy(tmp, psrc, n);
        psrc = tmp;
    }
 
    // 从前往后移动
    if (pdest <= psrc)
    {
        while (n--)
        {
            *pdest++ = *psrc++;
        }
    }
    // 从后往前移动
    else
    {
        pdest += n;
        psrc += n;
        while (n--)
        {
            *--pdest = *--psrc;
        }
    }
 
    // 释放临时缓冲区
    if (tmp != NULL)
    {
        free(tmp);
    }
 
    return dest;
}
 
int main()
{
    char str[] = "Hello World!";
    memmove(str + 6, str, 5);
    printf("%s\n", str);  // 输出 "Hello Hello!"
 
    return 0;
}

在上述代码中，


首先使用指针将目标地址和源地址转换为char*类型，然后根据目标地址和源地址的位置关系选择从前往后移动还是从后往前移动。如果目标地址在源地址之后，那么从后往前移动；如果目标地址在源地址之前，那么从前往后移动。在从后往前移动的时候，需要先将指针移动到末尾，然后再从后往前复制。如果目标地址和源地址重叠，就需要借用一个临时缓冲区来做中间存储。最后，注意释放临时缓冲区的内存。


方法二 

void * memmove ( void * dst, const void * src, size_t count)
{
  void * ret = dst;
​
  if (dst <= src || (char *)dst >= ((char *)src + count)) {
    /*
    * Non-Overlapping Buffers
    * copy from lower addresses to higher addresses
    */
    while (count--) {
        *(char *)dst = *(char *)src;
        dst = (char *)dst + 1;
        src = (char *)src + 1;
     }
   }
  else {
    /*
    * Overlapping Buffers
    * copy from higher addresses to lower addresses
    */
    dst = (char *)dst + count - 1;
    src = (char *)src + count - 1;
​
    while (count--) {
        *(char *)dst = *(char *)src;
        dst = (char *)dst - 1;
        src = (char *)src - 1;
     }
   }
  return(ret);
}

6. 模拟实现strlen

trlen函数用于计算字符串的长度（不包括字符串末尾的'\0'），


以下是C语言模拟实现strlen的代码：

#include <stdio.h>
 
int my_strlen(const char *s) {
    int len = 0;
    while (*s != '\0') {   // 循环条件为当前字符不是字符串末尾的'\0'
        len++;             // 长度加一
        s++;               // 指针后移
    }
    return len;
}
 
int main() {
    char str[] = "Hello, world!";
    printf("length of str: %d\n", my_strlen(str));   // 输出长度为13
    return 0;
}


这里的my_strlen函数和strlen的参数相同，都是一个指向char的指针。在函数内部，使用while循环遍历整个字符串，每遍历一个字符就把长度加一，最后返回计算出的长度。


1.计数器方式

int my_strlen(const char * str)
{
 int count = 0;
 while(*str)
 {
  count++;
  str++;
 }
 return count;
}

2.不能创建临时变量计数器

int my_strlen(const char * str)
{
 if(*str == '\0')
  return 0;
 else
  return 1+my_strlen(str+1);
}

3.指针-指针的方式

int my_strlen(const char *s)
{
   char *p = s;
   while(*p != ‘\0’ )
       p++;
   return p-s;
}

7.模拟实现strcpy

strcpy函数是C语言中的一个字符串拷贝函数，


用于将一个字符串中的内容拷贝到另一个字符串中。


以下为C语言模拟实现strcpy的代码： 


char* my_strcpy(char* dest, const char* src)
{ 
 char* ret = dest;
 assert(dest != NULL);
 assert(src != NULL);
 
 while((*dest++ = *src++))
 {
  ;
 }
 return ret;
}
#include <stdio.h>
 
char* my_strcpy(char* dest, const char* src) {
    char* p = dest;
    while (*src) {
        *dest++ = *src++;
    }
    *dest = '\0';
    return p;
}
 
int main() {
    char s1[20] = "Hello";
    char s2[20] = "World";
    printf("Before copy: %s %s\n", s1, s2);
    my_strcpy(s1, s2);
    printf("After copy: %s %s\n", s1, s2);
    return 0;
}

上述代码中，my_strcpy函数接受两个参数，一个为目的字符串（即需要被拷贝的字符串），另一个为要被拷贝的字符串（即源字符串）。在函数中，用p指针保存目的字符串的首地址，然后通过循环将源字符串中的每个字符一个一个地复制到目的字符串中，直到遇到源字符串结束符'\0'为止。最后在目的字符串末尾加上'\0'作为结束符，并返回目的字符串的首地址。在main函数中，首先输出两个字符串的初始值，然后调用my_strcpy函数将s2字符串的内容复制到s1字符串中，并输出两个字符串的最终值。


输出结果如下：

Before copy: Hello World
After copy: World World
文章标签：
C语言
存储
关键词：
C语言库
C语言函数
C语言库函数
小李很执着
目录
相关文章
白子寰
|
19天前
|
C语言 C++
C语言 之 内存函数
C语言 之 内存函数
白子寰
30 3
ephemerals__
|
10天前
|
存储 缓存 C语言
【c语言】简单的算术操作符、输入输出函数
本文介绍了C语言中的算术操作符、赋值操作符、单目操作符以及输入输出函数 `printf` 和 `scanf` 的基本用法。算术操作符包括加、减、乘、除和求余，其中除法和求余运算有特殊规则。赋值操作符用于给变量赋值，并支持复合赋值。单目操作符包括自增自减、正负号和强制类型转换。输入输出函数 `printf` 和 `scanf` 用于格式化输入和输出，支持多种占位符和格式控制。通过示例代码详细解释了这些操作符和函数的使用方法。
ephemerals__
30 10
c的前世今生
|
3天前
|
存储 算法 程序员
C语言：库函数
C语言的库函数是预定义的函数，用于执行常见的编程任务，如输入输出、字符串处理、数学运算等。使用库函数可以简化编程工作，提高开发效率。C标准库提供了丰富的函数，满足各种需求。
c的前世今生
8 1
ephemerals__
|
8天前
|
机器学习/深度学习 C语言
【c语言】一篇文章搞懂函数递归
本文详细介绍了函数递归的概念、思想及其限制条件，并通过求阶乘、打印整数每一位和求斐波那契数等实例，展示了递归的应用。递归的核心在于将大问题分解为小问题，但需注意递归可能导致效率低下和栈溢出的问题。文章最后总结了递归的优缺点，提醒读者在实际编程中合理使用递归。
ephemerals__
32 7
ephemerals__
|
8天前
|
存储 编译器 程序员
【c语言】函数
本文介绍了C语言中函数的基本概念，包括库函数和自定义函数的定义、使用及示例。库函数如`printf`和`scanf`，通过包含相应的头文件即可使用。自定义函数需指定返回类型、函数名、形式参数等。文中还探讨了函数的调用、形参与实参的区别、return语句的用法、函数嵌套调用、链式访问以及static关键字对变量和函数的影响，强调了static如何改变变量的生命周期和作用域，以及函数的可见性。
ephemerals__
22 4
c的前世今生
|
13天前
|
存储 编译器 C语言
C语言函数的定义与函数的声明的区别
C语言中，函数的定义包含函数的实现，即具体执行的代码块；而函数的声明仅描述函数的名称、返回类型和参数列表，用于告知编译器函数的存在，但不包含实现细节。声明通常放在头文件中，定义则在源文件中。
c的前世今生
21 5
ly~
|
19天前
|
数据可视化 BI API
除了 OpenGL，还有哪些常用的图形库可以在 C 语言中使用？
除了OpenGL，C语言中还有多个常用的图形库：SDL，适合初学者，用于2D游戏和多媒体应用；Allegro，高性能，支持2D/3D图形，广泛应用于游戏开发；Cairo，矢量图形库，支持高质量图形输出，适用于数据可视化；SFML，提供简单接口，用于2D/3D游戏及多媒体应用；GTK+，开源窗口工具包，用于创建图形用户界面。这些库各有特色，适用于不同的开发需求。
ly~
36 4
禁默
|
20天前
|
C语言
c语言回顾-函数递归（上）
c语言回顾-函数递归（上）
禁默
29 2
GuGuStudy
|
21天前
|
Java 编译器 C语言
【一步一步了解Java系列】：Java中的方法对标C语言中的函数
【一步一步了解Java系列】：Java中的方法对标C语言中的函数
GuGuStudy
18 3
努力学习的小廉
|
25天前
|
存储 程序员 编译器
C语言——动态内存管理与内存操作函数
C语言——动态内存管理与内存操作函数
努力学习的小廉
37 2