关于程序员:掌握字符与字符串C语言中的神奇函数解析三

✨✨ 欢送大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：C 语言学习
贝蒂的主页：Betty‘s blog

1. 简介

除了字符函数和字符串函数，<string.h> 中还有一类 内存操作函数 ，如 memset()，memcmp() 等函数，他们在性能和某些字符串函数很像，但作用范畴更广，除了作用于字符串外，还能够作用于 int，double 等内置类型，但因为是以字节为单位扭转，所以限度也很大。上面就让咱们来看看吧

2. memset()函数

2.1 用法

1. 申明：void memset(void str, int c, size_t n)

   • str — 指向要填充的内存块。
   • c — 要被设置的值。该值以 int 模式传递，然而函数在填充内存块时是应用该值的无符号字符模式。
   • n — 要被设置为该值的字符数。
2. 作用：复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符。
3. 返回值：该值返回一个指向存储区 str 的指针。

• memset()函数罕用于初始化

2.2 实例

#include <stdio.h>
#include <string.h>
int main()
{char str[] = "hello world";
    memset(str, 'x', 6);// 以字节为单位
    printf(str);
    return 0;
}

输入后果：xxxxxxworld

int main()
{int arr[4] = {1,2,3,4};
    memset(arr, 1, sizeof(arr));
    int i = 0;
    for (i = 0; i < 4; i++)
    {printf("%d", arr[i]);
    }
    return 0;
}

输入后果：16843009 16843009 16843009 16843009

• 尽管 memset 能够作用于 int，float 等类型，然而 memset 设置是以字节为单位，容易造成不合乎咱们预期的状况。

咱们也能够通过查看内存来验证一下：

2.3 实现 memset()

思路：memset()函数和 strcpy()函数有点像，都是替换，然而外在实现也有区别，因为 memset()函数还能够用于不同数据类型，所以要先强制类型为(char*)，再以字节为单位替换。

代码实现：

#include <string.h>
#include<assert.h>
void* my_memset(void*str, int c, size_t n)
{assert(str);// 避免 str 为空指针
    char* tmp= (char*)str;// 以字节为单位扭转
    while (n--)
    {
        *tmp = c;
        tmp++;
    }
    return str;
}
int main()
{char str[] = "hello world";
    my_memset(str, 'x', 6);// 以字节为单位
    printf(str);
    return 0;
}

3. memcmp()函数

3.1 用法

1. 申明：int memcmp(const void str1, const void str2, size_t n)

• str1 — 指向内存块的指针。
• str2 — 指向内存块的指针。
• n — 要被比拟的字节数。

2. 作用：把存储区 str1 和存储区 str2 的前 n 个字节进行比拟。
3. 返回值：

• 如果返回值 < 0，则示意 str1 小于 str2。
• 如果返回值 > 0，则示意 str1 大于 str2。
• 如果返回值 = 0，则示意 str1 等于 str2。

3.2 实例

#include <stdio.h>
#include <string.h>
int main() 
{char str1[] = "Hello, World!";
    char str2[] = "Hello, World!";
    char str3[] = "Hello, Betty!";
    // 比拟雷同的字符串
    if (memcmp(str1, str2, strlen(str1)) == 0)
    {printf("str1 和 str2 雷同。\n");
    }
    // 比拟不同的字符串
    if (memcmp(str1, str3, strlen(str1)) != 0) 
    {printf("str1 和 str3 不同。\n");
    }
    return 0;
}

输入：

str1 和 str2 雷同。
str1 和 str3 不同。

3.3 实现 memcmp()

思路：总体思路与 strncmp 差不多，只是也须要先强制类型转换

#include<stdio.h>
#include<assert.h>
int my_memcmp(const void* str1, const void* str2, size_t n)
{assert(str1 && str2);//
    char* p1 = (char*)str1;
    char* p2 = (char*)str2;
    while (n--&&(*p1==*p2))
    {if (*p1 == '\0')
        {return 0;}
        p1++;
        p2++;
    }
    return *p1 - *p2;
}

• memcmp()函数也是以字节比拟，所以限度也很大

3.4 strcmp，strncmp，memcmp 之间的区别

• memcmp 是比拟两个存储空间的 前 n 个字节，即便字符串曾经完结，依然要比拟残余的空间，直到比拟完 n 个字节。
• strcmp 比拟的是 两个字符串，任一字符串完结，则比拟完结。
• strncmp 在 strcmp 的根底上减少比拟 个数，其完结条件包含任一字符串完结和比拟完 n 个字节。
• strcmp 比拟的 字符串 ，而 memcmp 比拟的是 内存块，strcmp 须要时刻查看是否遇到了字符串完结的 \0 字符，而 memcmp 则齐全不必放心这个问题，所以memcmp 的效率要高于 strcmp

4. memcpy()函数

4.1 用法

1. 申明：void memcpy(void str1, const void *str2, size_t n)

• str1 — 指向用于存储复制内容的指标数组，类型强制转换为 void* 指针。
• str2 — 指向要复制的数据源，类型强制转换为 void* 指针。
• n — 要被复制的字节数。

2. 作用：从存储区 str2 复制 n 个字节到存储区 str1。
3. 返回值：该函数返回一个指向指标存储区 str1 的指针。

4.2 实例

int main()
{int arr1[] = {1,2,3,4,5,6,7,8,9,10};
    int arr2[10] = {0};
    memcpy(arr2, arr1, 20);// 前五个元素
    int i = 0;
    for (i = 0; i < 10; i++)
    {printf("%d", arr2[i]);
    }
    return 0;
}

输入后果：1 2 3 4 5 0 0 0 0 0

4.3 实现 memcpy()

思路：天然也是和 strcpy()差不多啦

void* my_memcpy(void* dest, const void* src, size_t n)
{assert(dest && src);// 避免空指针
    void* ret = dest;
    while (n--)
    {*(char*)dest = *(char*)src;
        dest = (char*)dest + 1;
        src = (char*)src + 1;
    }
    return ret;
}

• 因为 memcpy()函数实现机制，所以不能自己对本人进行拷贝。

4.4 strcpy，strncpy，memcpy 之间的区别

1. memcpy 是从 源存储空间拷贝到指标存储空间 ；而 strcpy，strncpy 是从 源字符串拷贝到指标字符串。
2. memcpy 拷贝时是依照 参数 n 作为完结标记的，即拷贝 n 个字节就完结；strncpy 是以参数 n 或者 ‘\0’ 为完结标记；strcpy 是判断‘\0’为完结标记。

5. memmove()函数

5.1 用法

咱们下面说过 memcpy()无奈对本人进行拷贝，那有没有能对本人拷贝的函数呢，当然有啦，就是咱们的 memmove()函数。

1. 申明：void memmove(void str1, const void *str2, size_t n)

• str1 — 指向用于存储复制内容的指标数组，类型强制转换为 void* 指针。
• str2 — 指向要复制的数据源，类型强制转换为 void* 指针。
• n — 要被复制的字节数。

2. 作用：从 str2 复制 n 个字符到 str1，然而在重叠内存块这方面，memmove() 是比 memcpy() 更平安的办法。如果指标区域和源区域有重叠的话，memmove() 可能保障源串在被笼罩之前将重叠区域的字节拷贝到指标区域中，复制后源区域的内容会被更改。如果指标区域与源区域没有重叠，则和 memcpy() 函数性能雷同。
3. 返回值：该函数返回一个指向指标存储区 str1 的指针。

5.2 实例

#include <stdio.h>
#include <string.h>
int main() 
{char str[] = "Hello, World!";
    printf("Original string: %s\n", str);
    // 将字符串前 6 个字符挪动到字符串的开端
    memmove(str, str + 7, 6);
    printf("Modified string: %s\n", str);
    return 0;
}

输入后果：

Original string: Hello, World!
Modified string: World! World!

5.3 实现 memmove()

剖析如下：

状况 1：

// 假如须要拷贝以下场景
int arr1[9] = {1,2,3,4,5,6,7,8,9};
my_memmove(arr1, arr1 + 2, 12);

1. 假如咱们从 3 的地位开始拷贝，3-1,4-2,5-3，拷贝胜利。

2. 假如咱们从 5 的地位开始拷贝，5-3,4-2,5-1，拷贝失败。

   状况 2：

// 假如咱们要拷贝的状况如下
int arr1[9] = {1,2,3,4,5,6,7,8,9};
my_memmove(arr1+4, arr1 + 2, 12);

1. 假如咱们从 3 的地位开始拷贝，3-5,4-6,3-7，拷贝失败。

2. 如果咱们从 5 的地位开始拷贝，:5-7,4-6,3-5，拷贝胜利。

   状况 3：

int arr1[9] = {1,2,3,4,5,6,7,8,9};
my_memmove(arr1+1, arr1 + 5, 12);
my_memmove(arr1 + 5, arr1 + 1, 12);

1. 假如从 6 开始拷贝，6-2,7-3,8-4，拷贝胜利。
2. 假如从 8 开始拷贝，8-4,7-3,6-2，拷贝胜利。

1. 假如从 2 开始拷贝，2-6,3-7,4-9，拷贝胜利。
2. 假如从 4 开始拷贝，4-8,3-7,2-6，拷贝胜利。

总结：如果 dest 字符串在 src 的字符右边，则从首元素拷贝。如果 dest 字符串在 src 左边，则从开端元素开始拷贝。

代码实现:

void* my_memmove(void* dest, const void* src, size_t n)
{assert(dest && src);// 避免空指针
    void* ret = dest;
    if (dest <= src)//dest 在 src 左侧
    {while (n--)
        {*(char*)dest = *(char*)src;
            dest = (char*)dest + 1;
            src = (char*)src + 1;
        }
    }
    else//dest 在 src 的右侧
    {dest = (char*)dest + n - 1;// 指向开端
        src = (char*)src + n - 1;// 指向开端
        while (n--)
        {*(char*)dest = *(char*)src;
            dest = (char*)dest - 1;
            src = (char*)src - 1;
        }
    }
    return ret;
}

​ 🎈🎈完结撒花🎈🎈

​ 🎈🎈完结撒花🎈🎈