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

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

所属专栏：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 -- 要被比拟的字节数。
  1. 作用：把存储区 str1 和存储区 str2 的前 n 个字节进行比拟。
  2. 返回值：
  • 如果返回值 < 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 -- 要被复制的字节数。
  1. 作用：从存储区 str2 复制 n 个字节到存储区 str1。
  2. 返回值：该函数返回一个指向指标存储区 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 -- 要被复制的字节数。
  1. 作用：从 str2 复制 n 个字符到 str1，然而在重叠内存块这方面，memmove() 是比 memcpy() 更平安的办法。如果指标区域和源区域有重叠的话，memmove() 可能保障源串在被笼罩之前将重叠区域的字节拷贝到指标区域中，复制后源区域的内容会被更改。如果指标区域与源区域没有重叠，则和 memcpy() 函数性能雷同。
  2. 返回值：该函数返回一个指向指标存储区 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;}

完结撒花

完结撒花