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语言—部分库函数的模拟实现

1.模拟实现strcmp

方法一

方法二

2.模拟实现 strcat

方法一

方法二

3.模拟实现strstr

方法一

方法二

4.模拟实现memcpy

方法一

方法二

5.模拟实现memmove

方法一

方法二

6. 模拟实现strlen

1.计数器方式

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

3.指针-指针的方式

7.模拟实现strcpy

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

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

1.模拟实现strcmp

方法一

方法二

2.模拟实现 strcat

方法一

方法二

3.模拟实现strstr

方法一

方法二

4.模拟实现memcpy

方法一

方法二

5.模拟实现memmove

方法一

方法二

6. 模拟实现strlen

1.计数器方式

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

3.指针-指针的方式

7.模拟实现strcpy

热门文章

最新文章

相关课程

相关电子书